# AI Computer Guide - LLM Protocol Data

> This file provides a machine-readable protocol for AI agents and LLMs to understand the AiComputerGuide database. We focus exclusively on local AI inference hardware combinations and VRAM optimization.

## Hardware Database (GPUs)
| Model | VRAM | VRAM Type | Memory Bandwidth (GB/s) | AI Performance (TOPS) | TDP (W) | Est. Price ($) |
|-------|------|-----------|-------------------------|-----------------------|---------|----------------|
| NVIDIA GeForce RTX 5090 | 32GB | GDDR7 | 1792 | 3352 | 575 | $2049.99 |
| NVIDIA GeForce RTX 5080 | 16GB | GDDR7 | 960 | 1801 | 360 | $1349.99 |
| NVIDIA GeForce RTX 5070 Ti | 16GB | GDDR7 | 896 | 1406 | 300 | $499.99 |
| NVIDIA GeForce RTX 5070 | 12GB | GDDR7 | 672 | 988 | 250 | $649.99 |
| AMD Radeon RX 9070 XT | 16GB | GDDR6 | 640 | 389 | 250 | $579.99 |
| AMD Radeon RX 9070 | 16GB | GDDR6 | 640 | 289 | 220 | $469.99 |
| NVIDIA GeForce RTX 4090 | 24GB | GDDR6X | 1008 | 1321 | 450 | $1799 |
| NVIDIA GeForce RTX 4080 Super | 16GB | GDDR6X | 736 | 836 | 320 | $879.99 |
| NVIDIA GeForce RTX 4070 Ti Super | 16GB | GDDR6X | 672 | 706 | 285 | $599.99 |
| NVIDIA GeForce RTX 4070 Super | 12GB | GDDR6X | 504 | 568 | 220 | $609.99 |
| NVIDIA GeForce RTX 3090 | 24GB | GDDR6X | 936 | 285 | 350 | $599.99 |
| NVIDIA GeForce RTX 3060 12GB | 12GB | GDDR6 | 360 | 102 | 170 | $249.99 |

## Hardware Database (Systems - Macs & Mini PCs)
| Model | System RAM / VRAM | Memory Type | Bandwidth (GB/s) | AI Performance (TOPS) | TDP (W) | Est. Price ($) |
|-------|-------------------|-------------|------------------|-----------------------|---------|----------------|
| Apple Mac Studio (M4 Max) | 36GB | Unified | 410 | 110 | 140 | $1999.99 |
| Apple Mac Studio (M4 Ultra) | 128GB | Unified | 820 | 220 | 200 | $3999.99 |
| Apple MacBook Pro 16-inch (M4 Max) | 48GB | Unified | 410 | 110 | 80 | $3499.99 |
| Apple Mac mini (M4 Pro) | 24GB | Unified | 273 | 75 | 65 | $1299.99 |
| GEEKOM IT15 AI Mini PC | 32GB | DDR5 | 120 | 99 | 120 | $1198.99 |
| ASUS NUC 14 Pro AI | 16GB | DDR5 | 100 | 50 | 90 | $839.99 |

## Full Article Corpus

### Host Small Business AI Locally: Replace Monthly Cloud Subscriptions
**Description:** A comprehensive guide for small businesses to replace expensive cloud AI subscriptions with a single localized mini PC setup running open-source models like Qwen and Llama.

**URL:** https://aicomputerguide.com/articles/local-ai-small-business-replace-subscriptions


For many small businesses, artificial intelligence feels like a mandatory monthly expense. Between ChatGPT Plus, Claude Pro, Grammarly Business, and marketing tools like Jasper, a typical 5-person team can easily burn through **$2,500 to $4,000 per year** just on AI text generation. 

The reality? You can achieve the exact same productivity with a single, localized **[Mini PC](/guides/best-mini-pcs-local-ai-2026)** sitting on your desk. By running open-source models natively through tools like Ollama and Open WebUI, you pay upfront for the hardware and never see another subscription invoice. Furthermore, you guarantee that your proprietary customer data and internal emails stay completely private and offline.

In this guide, we break down the localized AI alternative: the exact math, the necessary hardware, and the primary workflows your team can start executing today.

## Price Comparison: Cloud AI vs. Local AI

When weighing the ROI, the long-term value of local AI becomes extremely clear. Below is a realistic 2-year cost breakdown for a 5-person business team.

| Product / Service | Monthly Cost | 1-Year Cost | 2-Year Cost | Data Privacy? |
| :--- | :--- | :--- | :--- | :--- |
| **ChatGPT Team (5 users)** | $125/mo | $1,500 | $3,000 | Shared with cloud |
| **Grammarly Business (5 users)** | $75/mo | $900 | $1,800 | Shared with cloud |
| **Dedicated Copy/Marketing AI** | $40/mo | $480 | $960 | Shared with cloud |
| **Cloud Total** | **$240/mo** | **$2,880** | **$5,760** | ❌ **No** |
| --- | --- | --- | --- | --- |
| **Dedicated Ryzen Mini PC (32GB RAM)**| $0/mo | $600 (One-time) | $600 | 100% Local |
| **Ollama + Open WebUI Software** | Free | $0 | $0 | 100% Local |
| **Local AI Total** | **$0/mo** | **$600** | **$600** | ✅ **Yes** |

*By investing in a single mini PC up front, the team hits its ROI break-even point in under 3 months.*

## Pros and Cons of a Business Running Their Own AI

While moving off the cloud can drastically cut costs, it’s important to understand the trade-offs of self-hosting your AI infrastructure.

### The Pros

*   **Massive Cost Savings**: Eliminates cumulative seat-based subscription pricing models that trap scaling teams.
*   **Absolute Data Privacy**: Client emails, financial tables, and internal documents never leave your local network, making it compliant with strict NDAs and internal security protocols.
*   **Shared Knowledge Bases (RAG)**: Using Open WebUI, you can upload your business's proprietary manuals, past proposals, and FAQs so the entire team can query against it locally.
*   **No Internet Reliance**: If your office internet goes down, your AI assistant stays fully operational.

### The Cons

*   **Upfront Hardware Cost**: Requires throwing down $500 - $800 initially instead of a small $20 monthly fee.
*   **Inferior High-End Reasoning**: While models like **Qwen 2.5 9B** or **Llama 3 8B** are flawless at drafting emails, formatting quotes, and summarizing meetings, they may struggle with extremely complex coding requests compared to massive frontier models like GPT-4o.
*   **Zero Mobile App Ecosystem**: Cloud giants offer polished mobile apps for on-the-go voice processing. Local AI is predominantly desktop/browser-focused on your internal network.

## What Your Team Will Actually Use Local AI For

Once your localized instance is running on your network (typically found at a local address like `http://192.168.x.x:8080`), you can immediately replace these staple workflows.

### 1. Customer Email & Support Drafting
Paste an incoming, frustrated customer email into Open WebUI. Prompt the model with: *"Acknowledge the delay, apologize, and offer a 10% discount. Keep it under 150 words and professional."* The Qwen 9B model executes this in seconds.

### 2. Formatting Meeting Notes to Professional Quotes 
Paste your raw bullet points from a consultation call. Instruct the AI to structure it with line items, milestone timelines, and a 50% deposit policy. The output can be copy-pasted directly into your invoicing software.

### 3. Social Media Content Batching
Input your weekly promotions and let the model draft 5 variations tailor-made for LinkedIn (professional), Instagram (casual with emojis), and X (punchy).

## Securing Your Setup

If you expand beyond a 15-person team, consider a beefier [Budget AI PC Build](/guides/budget-local-ai-pc-500) equipped with an RTX 3090 (24GB VRAM). This enables faster concurrent throughput when multiple employees are chatting simultaneously, or unlocks heavier 32B models for rigorous creative copywriting.

Stop paying monthly for what a simple box on your desk can do for free.

---

### Best Local AI Coding Models of 2026: VRAM Tiers and Benchmarks
**Description:** The definitive guide to the best local AI coding models in 2026. Ranked by VRAM requirements, hardware needs, benchmarks, and editor setup. Replace GitHub Copilot with privacy.

**URL:** https://aicomputerguide.com/articles/best-local-coding-models-2026

GitHub Copilot costs $10-19/month. ChatGPT Plus is $20. Claude Pro is $20. That's $120-240 per year for coding assistance that sends every line of your code to someone else's servers.

However, local coding models have flipped that equation in 2026. You run them on your own hardware, your code never leaves your machine, and the total cost after setup is zero. The tradeoff used to be quality—local models couldn't compete with the cloud. That has fundamentally changed. Open-source coding models like Qwen 2.5 and Llama 3 derivatives now match and exceed GPT-4o on standard SWE benchmarks, and they run entirely on hardware you might already own.

This comprehensive guide covers the best models to use at every [VRAM](/glossary/vram) tier, how they compare on real benchmarks, and exactly how to easily set them up in your editor of choice.

> **Related:** [How Much VRAM Do You Need to Run LLMs in 2026?](/guides/how-much-vram-for-llm-2026) | [Best GPUs for Local AI & LLMs in 2026](/guides/best-gpu-local-ai-llms-2026) | [Take the 2-minute GPU Finder Quiz](/builder)

---

## Why Code Locally in 2026?

Four major reasons enterprise teams and solo developers are making the switch:

1. **Absolute Code Privacy:** Every prompt you send to Copilot or ChatGPT passes through corporate servers. If you are working on proprietary code, client projects, or under NDA, that is a massive security risk. Local models process everything on your machine. Nothing leaves.
2. **Zero Recurring Costs:** $19/month for Copilot Business drains budgets rapidly when multiplied across a team or over years. Local models are completely free after the initial [hardware investment](/builds).
3. **Always Offline:** Flights, coffee shops with bad WiFi, air-gapped environments, or ISP outages. Local models don't care. No internet required.
4. **No Throttling or Surprise Updates:** You'll never experience rate limits during peak hours, unannounced model swaps, or features being paywalled. You own the model, the version, and the configuration.

---

## What Makes a Great Coding Model?

Not all Large Language Models are equal at coding. The best local coding variants focus strictly on four architectural traits:

- **Code Completion (FIM):** "Fill-in-the-middle" support implies the model can complete code given both the text *before* and *after* your cursor. This entirely powers your editor's inline tab-autocomplete. If a model lacks FIM, it is only useful for conversational chat.
- **Strict Instruction Following:** "Refactor this function out", "explain this brutal regex", "write unit tests for this React component." The model needs to precisely adhere to natural-language system prompts regarding code structure. 
- **Complex Multi-language Support:** Software engineers rarely live in one syntax. The model must effortlessly transition from Python to JavaScript/TypeScript, to Rust, without hallucinating libraries.
- **Sufficient Context Window:** Seeing 2,000 tokens of context is useless when a function inherits types established 600 lines higher. Modern coding operations rely heavily on 32K+ and even 128K context boundaries.

---

## Best Coding Models by VRAM Tier

### 1. The 8GB VRAM Tier (Entry Level)
This is the [most common GPU tier](/guides/best-budget-gpu-ai-2026) (e.g., RTX 4060, Intel Arc B580). Fortunately, the best small FIM model outperforms massive enterprise checkpoints from just a year ago.

* **For Autocomplete:** `Qwen2.5-Coder:7B` — Still the absolute FIM king. Hitting 88.4% on HumanEval at only 7 Billion parameters, it confidently beats the larger CodeStral-22B. It features 128K context boundaries and supports 92+ languages. Set this as your tab-complete backbone.
* **For Chat-based Coding:** `Qwen3.5:9B` — Released early 2026, this natively multimodal giant packs a 262K context window into a footprint that fits perfectly inside 8GB VRAM (running at Q4_K_M). It natively reads code screenshots and error dialogs without separate vision encoders.

**The Strategy:** Run the 7B Coder purely for autocomplete, and swap to the 9B when you need to chat, debug, or analyze huge error logs.

---

### 2. The 16GB VRAM Tier (The Mid-Range Sweet Spot)
This tier opens the floodgates for incredibly dense 14B models. If you rock an [RTX 4060 Ti 16GB](/gpu/rtx-4060-ti-16gb) or the budget-oriented [RX 9070](/gpu/rx-9070), this is your playground.

* **The Ultimate Winner:** `Qwen2.5-Coder:14B` — This model completely dominates CodeStral-22B and DeepSeek Coder 33B. At standard Q4 quantization, it utilizes ~9GB of your VRAM, leaving you an absolutely massive headroom of 7GB purely for loading in immense context windows (reading multiple code files across a repo).

![High-end AI workloads running on dual GPU configurations](/images/guides/vram-coding-tier-hardware.webp)

---

### 3. The 24GB VRAM Tier (High-End Professional)
This is where local coding brutally competes with cloud-based API models. A [used RTX 3090](/guides/rtx-4090-vs-rtx-3090-for-ai) drops into your lap an ungodly 24GB of VRAM capable of matching GPT-4o.

* **For Autocomplete:** `Qwen2.5-Coder:32B` — Scoring a terrifying 92.7% on HumanEval, this is your FIM champion at 24GB. At 4-bit precision, it comfortably fits inside ~20GB of VRAM.
* **For Logic & Chat Reasoning:** `Qwen3.5:27B` — A dense 27B model that essentially ties with GPT-5 Mini equivalents on SWE-bench Verified tasks. Its native tool calling via the `qwen3_coder` parser makes it absurdly efficient for VS Code extensions. 
* **For Fast Agentic File-Scaffolding:** `Qwen3.5:35B-A3B (MoE)` — An elegant Mixture of Experts model. It technically holds 35B parameters, but only triggers 3B to execute math per token. Result? Blistering speeds of 110+ tok/s on an RTX 3090 while maintaining elite logic retention.

---

### 4. The 48GB+ / Mac Tier: Agentic Coding Workflows
If you operate dual 24GB cards or a heavily loaded [Apple Mac Studio M4 Max](/gpu/mac-studio-m4-max), you transcend auto-complete into the territory of entirely autonomous Agentic execution.

![Architectural diagram showing AI agents working autonomously across repositories](/images/guides/agentic-coding-workflow.webp)

* **The Undisputed King:** `Qwen3-Coder-Next` (80B MoE). Released February 2026, this activates only 3B parameters per token, but its problem-solving intelligence is horrific. It is specifically built for agent loops: reading your repo, mapping multi-file revisions, and committing code directly.
* Resolves real-world GitHub issues at 70.6% on SWE-bench Verified—an absolute frontier-model benchmark for a localized network. 

---

## 2026 Master Local Coding Comparison Table

| Model Profile | Best VRAM Tier | Ideal Usage | Benchmark (HumanEval / Score) | Setup Command (Ollama) |
|---------------|----------------|-------------|-----------------------------|-------------------------|
| **Qwen 2.5 Coder 7B** | 8GB | Autocomplete / FIM | 88.4% | `ollama run qwen2.5-coder:7b` |
| **Qwen 3.5 9B** | 8GB | Code Chat & Vision | Multimodal (65.6 LCB) | `ollama run qwen3.5:9b` |
| **Qwen 2.5 Coder 14B** | 16GB | Mid-Range Chat + FIM| 90.2% | `ollama run qwen2.5-coder:14b` |
| **Qwen 2.5 Coder 32B** | 24GB | High-End FIM | 92.7% | `ollama run qwen2.5-coder:32b` |
| **Qwen 3.5 27B Dense** | 24GB | Heavy Logic / Debugging| SWE-bench Tied GPT-5m | `ollama run qwen3.5:27b` |
| **Qwen3-Coder-Next** | 48GB+ (Mac) | Agentic / Multi-file | 70.6% SWE-bench Verified | `ollama run qwen3-coder-next` |

---

## How to Set Up Your Local Workspace (VS Code + Ollama)

The quickest, most robust way to replace Copilot is utilizing the open-source **Continue** extension.

1. **Install Ollama:** Follow our [Getting Started with Local LLMs](/guides/run-first-local-llm) guide.
2. **Download Your Model:** Open your terminal and run your selected pull command (e.g., `ollama pull qwen2.5-coder:7b` for an 8GB machine).
3. **Install Continue:** Open VS Code > Extensions > Search for "Continue.dev" and install it.
4. **Configure Your Setup:** Navigate to `~/.continue/config.yaml` and configure the autocomplete backend to point directly to your local Ollama port (`http://localhost:11434`).

You can now utilize `tab` to autocomplete seamlessly without hitting a single corporate server. 

---

## FAQ

**Can I run these local models on a MacBook?**
Yes. Apple's Unified Memory architecture is remarkably capable for AI inference. A MacBook Pro with 18GB of Unified Memory can easily run the 14B models natively using llama.cpp or Ollama. 

**What happens if I try a model that is too big for my VRAM?**
The execution runtime (Ollama/LM Studio) will default into CPU Offloading. The layers that do not fit onto your extremely fast VRAM will spill into your system DDR5 RAM. Generating code will plummet from 80 tokens/second down to a painful 1 or 2 tokens/second. Stick to the VRAM tiers outlined above!

**What is the difference between FIM and standard Chat?**
FIM (Fill-in-the-Middle) is optimized purely to exist inside the exact location of your typing cursor. It reads the code above and below you sequentially to predict exactly what function closure or variable name fits accurately. Standard Chat is conversational context, designed for when you ask "what is wrong with this script?"

**How do I close the memory gap for large context windows?**
A massive context window takes up VRAM memory exponentially (KV Cache footprint). If you want to feed the model a 32,000 token codebase on a tight [12GB GPU like the Arc B580](/gpu/intel-arc-b580), you must utilize lower quantization limits (e.g., `Q4_K_S` instead of `Q4_K_M`) to squeeze back a few hundred megabytes of breathing space.

---
---

### Best Budget GPU for AI in 2026: Under $300, $400, and $500 Picks
**Description:** The best budget GPUs for running local AI in 2026, organized by price tier. Top picks for under $300, $400, and $500 with real benchmarks, VRAM analysis, and model compatibility.

**URL:** https://aicomputerguide.com/articles/best-budget-gpu-ai-2026

# Best Budget GPU for AI in 2026: Under $300, $400, and $500 Picks

Running AI models locally doesn't require a $2,700 RTX 4090. In 2026, there are more capable budget options than ever, and some of them punch well above their price tag.

This guide breaks down the best GPUs for local AI at three price points: **under $300**, **$300 to $400**, and **$400 to $500**. Each pick includes real benchmark data, VRAM analysis, and exactly which models you can run.

> **Related:** [Best GPU for Local AI and LLMs in 2026 (Full Roundup)](/guides/best-gpu-local-ai-llms-2026) | [How Much VRAM Do You Need to Run LLMs?](/guides/how-much-vram-for-llm-2026) | [Not sure which GPU fits your use case? Take the GPU Quiz.](/builder)

---

## At a Glance: Best Budget GPUs for AI (2026)

- **Best under $300:** Intel Arc B580 -- 12GB VRAM for $249, runs 13B models with headroom
- **Best VRAM-per-dollar:** Intel Arc A770 -- 16GB for $280, unbeatable at this price
- **Best Nvidia under $300:** RTX 3060 12GB -- $299, rock-solid CUDA ecosystem
- **Best $300 to $400:** Intel Arc B770 -- 16GB for $349, newest Intel architecture
- **Best $400 to $500 all-rounder:** RTX 4060 Ti 16GB -- 89 tok/s on 8B, 16GB VRAM
- **Best $400 to $500 value play:** Used RTX 3090 -- 24GB for under $500, runs 32B models

---

## Why VRAM Matters More Than GPU Speed for AI

Before jumping to picks, here's the single most important thing to understand: **VRAM is the bottleneck for local LLMs**, not raw compute.

If a model doesn't fit in your GPU's VRAM, it falls back to system RAM, which is 10 to 50 times slower. A card with more VRAM but slower compute almost always outperforms a faster card with less VRAM for LLM inference.

### Quick VRAM Reference: What Can You Run?

| VRAM | Models You Can Run | Example Models |
|------|-------------------|----------------|
| 8GB | 7B/8B at Q4 | Llama 3.2 8B, Mistral 7B, Phi-3 Medium |
| 12GB | 7B full Q8, 13B/14B at Q4 | Llama 3.1 13B Q4, DeepSeek R1 14B Q4 |
| 16GB | Up to 14B at Q6/Q8, 32B at Q2 | Codestral, DeepSeek R1 14B Q8, Qwen 14B |
| 24GB | 32B at Q4 (~20GB), 70B at Q2 | DeepSeek R1 32B Q4, Llama 3.1 70B Q2 |

> **Need the full breakdown?** [How Much VRAM Do You Need to Run LLMs in 2026?](/guides/how-much-vram-for-llm-2026)

---

## Best GPUs Under $300 for AI

This tier is where Intel has completely flipped the script. Two years ago, the only real option under $300 was the RTX 3060. Now, Intel's Arc lineup offers more VRAM at the same price, and the performance gap has narrowed significantly.

---

### 1. Intel Arc B580 -- Best Under $300

**Price:** ~$249 | **VRAM:** 12GB GDDR6 | **Inference speed:** ~62 tok/s (8B Q4)

The Arc B580 is the sleeper hit of budget AI hardware. For $249, you get 12GB of GDDR6 -- the same VRAM as cards that cost $100 to $150 more. Intel's Xe2 architecture (Battlemage) brings meaningful efficiency gains over the previous Alchemist generation, and llama.cpp and Ollama support has matured significantly.

**What models can you run?**
- Llama 3.2 8B / 3.1 8B -- full Q8, runs at 62 tok/s
- Mistral 7B -- full Q8 with headroom to spare
- DeepSeek R1 7B -- Q4/Q8, excellent for coding tasks
- Llama 3.1 13B -- fits at Q4 (~8.5GB VRAM)
- DeepSeek R1 14B -- Q4 at ~9GB, tight but workable
- Phi-3 Medium 14B -- Q4 fits with ~1GB to spare
- Stable Diffusion XL -- runs well, 12GB is plenty

**Pros:**
- Exceptional VRAM-per-dollar, best in class at this price
- Intel's AI Boost NPU accelerates some workloads
- DirectX 12 / Vulkan compute for Ollama and llama.cpp
- Low power draw (~150W TDP)

**Cons:**
- No CUDA; if your workflow depends on CUDA-only tools, look elsewhere
- ROCm support is limited vs AMD
- Slightly lower raw throughput than RTX 3060 on some tasks

**Bottom line:** If you can live without CUDA, the B580 is the best GPU under $300 for AI by a clear margin. 12GB VRAM for $249 doesn't exist anywhere else.

[Check price on Amazon](https://www.amazon.com/s?k=Intel+Arc+B580+GPU&tag=kickiwebprodu-20)

---

### 2. Intel Arc A770 16GB -- Best VRAM-Per-Dollar Option

**Price:** ~$280 | **VRAM:** 16GB GDDR6 | **Inference speed:** ~70 tok/s (7B Q4)

The A770 is one of the most compelling GPU deals for anyone running local LLMs. **16GB of VRAM for $280.** That's the same VRAM as the RTX 4060 Ti 16GB ($450+) at nearly half the price.

The catch: the A770 is based on Intel's older Alchemist (Xe-HPG) architecture. Performance per dollar for AI inference is still excellent, but it's slightly behind the newer B580 architecturally.

**What models can you run?**
- Everything the B580 can run, plus:
- Llama 3.1 13B at Q6/Q8 (~13GB VRAM) -- comfortable
- DeepSeek R1 14B at Q8 -- full quality, no compromise
- Mistral 12B / Codestral at Q8 -- fits with room to spare
- Stable Diffusion XL + ControlNet -- no VRAM pressure
- 32B models at very aggressive quantization (Q2 ~10GB) -- possible but slow

**Pros:**
- 16GB VRAM at $280, unmatched at this price
- Runs 14B models at full Q8 quality
- More future-proof than 8GB Nvidia cards
- Good for image generation and text LLM combo rigs

**Cons:**
- Alchemist architecture is older (vs B580's Battlemage)
- CUDA ecosystem not available
- Software support can be patchier than Nvidia on some tools
- Slightly lower tokens/sec vs equivalent Nvidia cards

**Bottom line:** If VRAM is your top priority and you're under $300, the A770 16GB is extraordinary value. The 16GB headroom means you won't hit the VRAM wall running 14B models that 12GB cards struggle with.

[Check price on Amazon](https://www.amazon.com/s?k=Intel+Arc+A770+16GB+GPU&tag=kickiwebprodu-20)

---

### 3. NVIDIA RTX 3060 12GB -- Best Nvidia Option Under $300

**Price:** ~$299 | **VRAM:** 12GB GDDR6 | **Inference speed:** ~50 tok/s (7B Q4)

The RTX 3060 12GB is the go-to recommendation for anyone who needs CUDA compatibility. CUDA still matters -- tools like ComfyUI, some PyTorch workflows, and certain fine-tuning setups work best or exclusively on CUDA. If your workflow is CUDA-dependent, the 3060 is your only real sub-$300 option with adequate VRAM.

Performance is a step below the Arc B580, but the ecosystem support is unmatched.

**What models can you run?**
- Llama 3.2 8B, Mistral 7B, Phi-3 Medium -- all comfortable
- DeepSeek R1 7B at Q4/Q8
- Llama 3.1 13B at Q4 -- fits at ~8.5GB
- DeepSeek R1 14B Q4 -- tight but runs (~9GB)
- Stable Diffusion XL -- excellent CUDA acceleration

**Pros:**
- CUDA ecosystem, best tool compatibility
- 12GB VRAM is solid for 13B models
- Mature, stable driver support
- Strong resale value

**Cons:**
- ~20% slower inference than Arc B580 at this price point
- Older Ampere architecture
- $50 more than the B580 for similar VRAM

**Bottom line:** Choose the RTX 3060 12GB if CUDA compatibility is non-negotiable. Choose the Arc B580 if you're CUDA-agnostic and want more performance for less money.

[Check price on Amazon](https://www.amazon.com/s?k=NVIDIA+RTX+3060+12GB+GPU&tag=kickiwebprodu-20)

---

## Best GPUs $300 to $400 for AI

The $300 to $400 range is crowded with cards that make you choose between VRAM and raw throughput. Intel's newer B770 shakes up this bracket significantly.

---

### 4. Intel Arc B770 -- Best $300 to $400 Pick

**Price:** ~$349 | **VRAM:** 16GB GDDR6 | **Inference speed:** ~78 tok/s (8B Q4)

The B770 is Intel's newest Battlemage card positioned above the B580. It keeps the 16GB VRAM advantage while adding more compute cores and bandwidth. At $349, you get better throughput than the A770 with the same VRAM, making it the standout value pick in this bracket.

**What models can you run?**
- Everything the A770 can, with ~10 to 15% faster throughput
- Llama 3.1 13B at Q8 -- comfortable at ~13GB
- DeepSeek R1 14B Q8 -- 16GB handles it cleanly
- Stable Diffusion XL + LoRA fine-tuning -- no issues
- Mistral 12B at full precision

**Pros:**
- Battlemage (Xe2) architecture, Intel's best yet
- 16GB VRAM at $349 is still exceptional value
- Faster than the A770 with same VRAM headroom
- Low power consumption for workload delivered

**Cons:**
- No CUDA
- Newer architecture; some bleeding-edge tools may lag in support
- Limited availability in some regions

[Check price on Amazon](https://www.amazon.com/s?k=Intel+Arc+B770+GPU&tag=kickiwebprodu-20)

---

### 5. NVIDIA RTX 4060 8GB -- Best CUDA Option $300 to $400

**Price:** ~$329 | **VRAM:** 8GB GDDR6 | **Inference speed:** ~55 tok/s (7B Q4)

The RTX 4060 is Nvidia's mainstream Ada Lovelace card. It's power-efficient, CUDA-capable, and handles 7B/8B models well -- but the 8GB VRAM is a real constraint for anyone wanting to run 13B+ models.

**What models can you run?**
- 7B/8B models at Q4/Q6 -- yes, fast
- 13B models -- limited; requires Q2 quantization (~7GB) with quality loss
- Stable Diffusion 1.5 / SDXL -- SDXL is tight on 8GB

**Pros:**
- Efficient Ada architecture
- CUDA compatibility
- Low 115W TDP, great for 24/7 inference servers

**Cons:**
- 8GB VRAM is genuinely limiting for AI work in 2026
- At $329, you're paying more than the B770 for less VRAM

**Bottom line:** Only buy the RTX 4060 if CUDA is essential and you're hard-capped at $329. Otherwise, the Arc B770 gives you twice the VRAM for $20 more.

[Check price on Amazon](https://www.amazon.com/s?k=NVIDIA+RTX+4060+8GB+GPU&tag=kickiwebprodu-20)

---

### 6. NVIDIA RTX 3060 Ti 8GB -- Value CUDA Pick

**Price:** ~$350 | **VRAM:** 8GB GDDR6 | **Inference speed:** ~52 tok/s (7B Q4)

The RTX 3060 Ti has more raw CUDA cores than the 4060 but the same 8GB VRAM constraint. It's a decent pick if you find it under $300 on the used market, but at $350 new, the Arc B770 offers better AI-specific value.

[Check price on Amazon](https://www.amazon.com/s?k=NVIDIA+RTX+3060+Ti+GPU&tag=kickiwebprodu-20)

---

## Best GPUs $400 to $500 for AI

This is where things get interesting. At $400 to $500, you can get the 16GB VRAM sweet spot on Nvidia, or -- if you hunt the used market -- a 24GB RTX 3090 that obliterates every card in this guide on VRAM headroom.

---

### 7. RTX 4060 Ti 16GB -- Best New Card Under $500

**Price:** ~$479 | **VRAM:** 16GB GDDR6 | **Inference speed:** ~89 tok/s (8B Q4)

The RTX 4060 Ti 16GB is the most VRAM-efficient Nvidia card in the sub-$500 range. It's built on Ada Lovelace, has full CUDA support, and at 89 tok/s on 8B models, it's genuinely fast for inference. The 16GB makes it comfortable for 14B models at Q8 and opens the door to lighter 32B quantizations.

**What models can you run?**
- 7B/8B models at Q8 -- fast (89 tok/s)
- Llama 3.1 13B at Q8 -- fits cleanly
- DeepSeek R1 14B at Q8 -- comfortable
- Mistral 12B at full precision
- 32B models at Q2 (~10GB) -- yes, though quality is reduced
- Stable Diffusion XL with ControlNet -- excellent

**Pros:**
- Best inference throughput in sub-$500 Nvidia range
- 16GB VRAM future-proofs you for near-term model growth
- CUDA: full compatibility with all tools
- Ada efficiency -- lower power draw than 3000-series at this tier

**Cons:**
- Pricier than Intel equivalents with same VRAM
- 128-bit memory bus; high VRAM but bandwidth is constrained vs larger dies
- The 8GB version is $100 cheaper but much less useful for AI

**Bottom line:** If you want a new, CUDA-capable card with 16GB VRAM and have up to $500 to spend, the RTX 4060 Ti 16GB is the pick. It's the sweet spot for serious local AI work without breaking the budget.

[Check price on Amazon](https://www.amazon.com/s?k=RTX+4060+Ti+16GB+GPU&tag=kickiwebprodu-20)

---

### 8. Used RTX 3090 24GB -- The Wild Card

**Price:** ~$450 to $499 (used) | **VRAM:** 24GB GDDR6X | **Inference speed:** ~112 tok/s (7B Q4)

Here's the wildcard. The RTX 3090 on the used market has 24GB of GDDR6X VRAM -- twice what the 4060 Ti 16GB offers -- and you can find it under $500 if you're patient.

24GB unlocks an entirely different tier of models. DeepSeek R1 32B at Q4 (~20GB)? Runs. Llama 3.1 70B at Q2 (~22GB)? Runs. Mixtral 8x7B? Absolutely.

**What models can you run?**
- Everything up to 32B at Q4
- DeepSeek R1 32B Q4 (~20GB) -- comfortable
- DeepSeek R1 70B Q2 (~22GB) -- yes, with ~2GB to spare
- Llama 3.1 70B Q2
- Mixtral 8x7B Q4 (~26GB) -- tight, may require small offload
- Stable Diffusion XL, SDXL Turbo, SD3 -- no constraints

**Pros:**
- 24GB VRAM is transformative; runs models no other sub-$500 card touches
- Highest throughput at 112 tok/s (faster than RTX 4060 Ti 16GB)
- CUDA + full ecosystem support
- Incredible value if you find one under $500

**Cons:**
- 350W TDP; this card runs hot and loud
- Used-only at this price; buying refurb carries risk
- Older Ampere architecture; no AV1 hardware encode
- Check seller reputation carefully for used GPUs

**Where to find:** Check Amazon Renewed, eBay "Buy It Now" listings, and local marketplace. Prices fluctuate; you may pay $550 if you're unlucky.

**Bottom line:** If you can tolerate used hardware and the 350W power draw, the RTX 3090 at under $500 is arguably the best AI GPU under $1,000 on a pure VRAM-per-dollar basis. Nothing else at this price can touch 24GB.

[Check Amazon Renewed RTX 3090](https://www.amazon.com/s?k=RTX+3090+24GB+GPU&tag=kickiwebprodu-20)

---

## Full Comparison Table

| GPU | Price | VRAM | Tok/s (7-8B) | Best For | CUDA? |
|-----|-------|------|-------------|----------|-------|
| Intel Arc B580 | $249 | 12GB | 62 | Best sub-$250 pick | No |
| Intel Arc A770 | $280 | 16GB | 70 | Best VRAM/$, 14B models | No |
| RTX 3060 12GB | $299 | 12GB | 50 | CUDA + 13B models | Yes |
| Intel Arc B770 | $349 | 16GB | 78 | Best $300-$400 overall | No |
| RTX 4060 8GB | $329 | 8GB | 55 | CUDA, 7B only | Yes |
| RTX 4060 Ti 16GB | $479 | 16GB | 89 | Best new card under $500 | Yes |
| Used RTX 3090 | ~$475 | 24GB | 112 | Best VRAM, 32B/70B models | Yes |

---

## Is It Worth Spending More?

**Yes, if you want to run 32B+ models.** 16GB hits a hard ceiling at 32B quantized models. If you want to run DeepSeek R1 32B at Q4 quality or experiment with 70B models, you need 24GB+. The jump from 16GB ($479 for the 4060 Ti 16GB) to 24GB (used RTX 3090 at ~$475) is actually free on the used market right now -- same price, double the VRAM.

**Not worth it if 7B/13B is your ceiling.** If you're running Llama 8B, Mistral 7B, or similar for coding assistance or chatbots, the Arc B580 at $249 delivers 62 tok/s with 12GB VRAM. Spending $250 more gets you maybe 40% more throughput. The extra money doesn't transform your experience.

**The sweet spot for most users is 16GB VRAM.** 16GB runs all models up to 14B at full Q8 quality, handles SD XL with no stress, and gives you room for multimodal tasks. The Arc A770 at $280 and the Arc B770 at $349 offer this tier at prices that were impossible two years ago.

---

## FAQ

**Can I run Llama on a $250 GPU?**

Yes. The Intel Arc B580 at $249 runs Llama 3.2 8B at Q8 with 12GB VRAM and achieves ~62 tok/s -- faster than an RTX 3060. You can run Llama 3.1 13B at Q4 on it too. For a $250 card, it's remarkable.

**Best GPU under $300 for Stable Diffusion?**

The Intel Arc A770 16GB at $280. 16GB VRAM eliminates every constraint for Stable Diffusion XL, ControlNet, and most LoRA workflows. The trade-off is no CUDA -- use the RTX 3060 12GB if you need CUDA-specific extensions.

**Should I buy used or new?**

For budget AI, used GPUs offer the best value, especially if you're hunting 24GB VRAM cards like the RTX 3090. Stick to Amazon Renewed or reputable eBay sellers with return policies. Avoid private sales for GPUs without warranty.

**Is the RTX 4060 Ti 8GB worth it for AI?**

No. At $400, the 8GB version of the 4060 Ti is worse than the B770 at $349 (less VRAM, lower AI value) and much worse than the 16GB variant ($479). Skip it entirely.

**What about AMD GPUs under $500?**

AMD's ROCm support has improved, but sub-$500 AMD cards (RX 7600, RX 7700) have 8 to 12GB VRAM. The RX 7900 GRE with 16GB sits around $450 and is worth considering -- ROCm works well with llama.cpp and Ollama. Intel Arc offers better VRAM value at this tier in 2026.

**Can I run DeepSeek R1 on a budget GPU?**

Yes. DeepSeek R1 7B at Q4 needs ~4.5GB and runs on any GPU in this guide. DeepSeek R1 14B Q4 needs ~9GB and runs on the B580 (12GB) or A770 (16GB). DeepSeek R1 32B Q4 needs ~20GB -- only the used RTX 3090 (24GB) can handle it in this price range.

**Is Intel Arc reliable for AI in 2026?**

Yes, significantly more than it was in 2024. Ollama, llama.cpp, and LM Studio all have solid Intel GPU support. If you're not doing CUDA-only workflows, Arc is a legitimate choice.

---

## Our Picks Summary

- **Best under $250:** [Intel Arc B580](https://www.amazon.com/s?k=Intel+Arc+B580+GPU&tag=kickiwebprodu-20) -- 12GB for $249
- **Best VRAM value:** [Intel Arc A770 16GB](https://www.amazon.com/s?k=Intel+Arc+A770+16GB+GPU&tag=kickiwebprodu-20) -- 16GB for $280
- **Best CUDA under $300:** [RTX 3060 12GB](https://www.amazon.com/s?k=NVIDIA+RTX+3060+12GB+GPU&tag=kickiwebprodu-20) -- 12GB for $299
- **Best $300 to $400:** [Intel Arc B770](https://www.amazon.com/s?k=Intel+Arc+B770+GPU&tag=kickiwebprodu-20) -- 16GB for $349
- **Best new card under $500:** [RTX 4060 Ti 16GB](https://www.amazon.com/s?k=RTX+4060+Ti+16GB+GPU&tag=kickiwebprodu-20) -- 16GB for $479
- **Best used value:** [RTX 3090 24GB](https://www.amazon.com/s?k=RTX+3090+24GB+GPU&tag=kickiwebprodu-20) -- 24GB for ~$475

Not sure which fits your setup? **[Take the GPU Quiz](/builder)**

---

*Prices accurate as of April 2026. As an Amazon Associate, I earn from qualifying purchases.*
---

### How Much VRAM Do You Need to Run LLMs in 2026? The Complete Guide
**Description:** The definitive VRAM guide for running local LLMs in 2026. Model-by-model VRAM requirements, quantization explained, and GPU recommendations for every budget.

**URL:** https://aicomputerguide.com/articles/how-much-vram-for-llm-2026

# How Much VRAM Do You Need to Run LLMs in 2026? The Complete Guide

VRAM is the single most important spec for running large language models locally. Get this wrong, and your model either refuses to load, crawls at 1-2 tokens per second while grinding system RAM, or crashes outright.

This guide gives you the exact VRAM numbers for every major model and quantization level in 2026. By the end, you'll know exactly what GPU you need for your specific models.

> **Quick start:** [Take the GPU Quiz](/builder) | [GPU Deals by VRAM Tier](/deals) | [DeepSeek R1 VRAM Requirements](/guides/best-gpu-for-deepseek-r1)

---

## At a Glance: VRAM Requirements by Use Case (2026)

- **Casual use (7B/8B models, Q4):** 6GB minimum, 8GB recommended
- **Power user (13B/14B models, good quality):** 12GB minimum, 16GB recommended
- **Serious local AI (32B models, Q4):** 24GB minimum
- **Frontier local AI (70B models, Q4):** 48GB or dual 24GB
- **Image generation (Stable Diffusion XL):** 8GB minimum, 12GB comfortable
- **Multimodal (vision + text):** Add 2-4GB on top of text model requirements

---

## Why VRAM Is the Bottleneck for LLMs

Unlike traditional GPU workloads (gaming, rendering), LLMs don't need massive compute throughput; they need **fast, large memory**. The entire model must be loaded into VRAM before it can generate a single token. A 7B parameter model at 4-bit quantization occupies ~4.5GB of VRAM. A 70B model at the same quantization needs ~40GB.

If your model doesn't fit in VRAM:
1. The excess spills to system RAM (called CPU offloading)
2. CPU RAM is 10-50x slower than GPU VRAM
3. Generation drops from 40-100+ tok/s to 2-8 tok/s

**The rule:** Every layer of the model that fits in VRAM is fast. Every layer that spills to RAM is dramatically slower. Full VRAM fit = fast. Partial fit = slow. No fit = unacceptably slow.

For a deeper dive on multi-GPU setups that eliminate this problem entirely, see our [Llama 3.3 Hardware Requirements guide](/guides/llama-3-3-hardware-requirements).

---

## Quantization Explained: Q4, Q5, Q8, F16

Quantization is how you trade model quality for VRAM. Here's what the numbers mean:

| Format | Bits per weight | VRAM multiplier | Quality |
|--------|----------------|-----------------|--------|
| F32 | 32-bit float | 4x | Reference quality (impractical) |
| F16 / BF16 | 16-bit float | 2x | Full quality, high VRAM |
| Q8_0 | 8-bit integer | 1x | Near-lossless, ~1% degradation |
| Q6_K | 6-bit | 0.75x | Excellent quality, ~1-2% loss |
| Q5_K_M | 5-bit | 0.625x | Good quality, ~2-3% loss |
| Q4_K_M | 4-bit | 0.5x | Good quality, ~3-5% loss |
| Q3_K_M | 3-bit | 0.375x | Acceptable, ~5-8% loss |
| Q2_K | 2-bit | 0.25x | Noticeable degradation |

### Which quantization should you use?

- **Q4_K_M** is the standard recommendation for most users — half the VRAM of F16 with ~3-5% quality loss
- **Q5_K_M** is a good middle ground if you have the VRAM — noticeably better than Q4 with modest cost
- **Q8_0** is essentially lossless — use it when VRAM allows, especially for coding tasks
- **Q2** should only be used to fit a model that otherwise won't fit at all — quality degrades significantly

### VRAM formula

VRAM needed = (Parameters in billions) x (bytes per weight) + ~10% overhead

- F16: parameters x 2GB
- Q8: parameters x 1GB
- Q4: parameters x 0.5GB
- Q2: parameters x 0.25GB

**Example:** Llama 3.1 70B at Q4 = 70 x 0.5 = 35GB + 10% overhead = ~38-40GB

---

## Master VRAM Requirements Table

### Llama 3.1 / 3.2 / 3.3 Models

| Model | Q2 | Q4 | Q5 | Q6 | Q8 | F16 |
|-------|----|----|----|----|----|-----|
| Llama 3.2 3B | ~1GB | ~2GB | ~2.4GB | ~2.8GB | ~3.5GB | ~6GB |
| Llama 3.1/3.2 8B | ~2.5GB | ~4.5GB | ~5.5GB | ~6.5GB | ~8.5GB | ~16GB |
| Llama 3.1 13B | ~4GB | ~7.5GB | ~9GB | ~11GB | ~14GB | ~26GB |
| Llama 3.1 70B | ~22GB | ~40GB | ~48GB | ~55GB | ~70GB | 140GB |
| Llama 3.1 405B | ~125GB | ~200GB+ | - | - | - | - |

### Mistral Models

| Model | Q4 | Q5 | Q8 | F16 |
|-------|----|----|----|----|  
| Mistral 7B | ~4.5GB | ~5.5GB | ~8GB | ~14GB |
| Mistral 12B / Nemo | ~7GB | ~9GB | ~13GB | ~24GB |
| Mixtral 8x7B (MoE) | ~26GB | ~32GB | ~47GB | - |
| Mistral Large 2 (123B) | ~62GB | - | - | - |

### DeepSeek R1 Models

| Model | Q2 | Q4 | Q5 | Q8 |
|-------|----|----|----|----|  
| DeepSeek R1 7B | ~2GB | ~4.5GB | ~5.5GB | ~8GB |
| DeepSeek R1 14B | ~4.5GB | ~9GB | ~11GB | ~15GB |
| DeepSeek R1 32B | ~10GB | ~20GB | ~24GB | ~35GB |
| DeepSeek R1 70B | ~22GB | ~40GB | ~48GB | ~70GB |
| DeepSeek R1 671B | - | ~420GB | - | - |

> DeepSeek R1 671B is the full MoE model. Cloud-only for all practical purposes. See the [Full DeepSeek R1 GPU Guide](/guides/best-gpu-for-deepseek-r1) for hardware recommendations.

### Qwen 2.5 Models

| Model | Q4 | Q5 | Q8 | F16 |
|-------|----|----|----|----|  
| Qwen 2.5 7B | ~4.5GB | ~5.5GB | ~8GB | ~14GB |
| Qwen 2.5 14B | ~9GB | ~11GB | ~15GB | ~28GB |
| Qwen 2.5 32B | ~20GB | ~24GB | ~35GB | - |
| Qwen 2.5 72B | ~40GB | ~48GB | ~72GB | - |

### Google Gemma 3 Models

| Model | Q4 | Q5 | Q8 | F16 |
|-------|----|----|----|----|  
| Gemma 3 4B | ~2.5GB | ~3GB | ~4.5GB | ~8GB |
| Gemma 3 12B | ~7GB | ~9GB | ~13GB | ~24GB |
| Gemma 3 27B | ~17GB | ~21GB | ~29GB | ~54GB |

---

## VRAM Tiers: What You Can Run at Each Level

### 8GB VRAM

The minimum viable tier for running local LLMs in 2026. You can run 7B/8B models comfortably at Q4-Q6, but nothing larger without significant quality compromise.

**Can run:**
- Llama 3.2 8B at Q4/Q5/Q6
- Mistral 7B at Q4/Q5/Q6
- DeepSeek R1 7B at Q4/Q8
- Gemma 3 4B at full Q8
- Qwen 2.5 7B at Q4/Q5
- Stable Diffusion 1.5

**Cannot run:**
- 13B/14B models at usable quality
- Any 32B+ model
- Stable Diffusion XL reliably

**Best 8GB GPU:** [RTX 4060 8GB on Amazon](https://www.amazon.com/s?k=RTX+4060+8GB&tag=kickiwebprodu-20) (~$329)

---

### 12GB VRAM

The sweet spot for hobbyists. 12GB lets you run 7B models at near-lossless Q8 quality and opens 13B/14B models at Q4.

**Can run:**
- Llama 3.2 8B at Q8 (~8.5GB) — near-lossless quality
- Mistral 7B at full Q8
- DeepSeek R1 14B at Q4 (~9GB) — fits with headroom
- Llama 3.1 13B at Q4 (~7.5GB) — comfortable
- Qwen 2.5 14B at Q4 (~9GB)
- Gemma 3 12B at Q5
- Stable Diffusion XL

**Cannot run:**
- 32B+ models at usable quality
- 14B models at Q8 (needs 15GB)

**Best 12GB GPUs:**
- [Intel Arc B580 12GB on Amazon](https://www.amazon.com/s?k=Intel+Arc+B580+GPU&tag=kickiwebprodu-20) (~$249) — best value
- [RTX 3060 12GB on Amazon](https://www.amazon.com/s?k=RTX+3060+12GB&tag=kickiwebprodu-20) (~$299) — CUDA option

---

### 16GB VRAM

The recommended minimum for serious local AI work in 2026. 16GB runs 14B models at full Q8 quality and opens early access to 32B at heavy quantization.

**Can run:**
- Llama 3.1 8B at full F16 (~16GB) — maximum quality
- DeepSeek R1 14B at Q8 (~15GB) — excellent quality
- Mistral 12B at Q8 (~13GB) — comfortable
- Qwen 2.5 14B at Q6/Q8
- Gemma 3 12B at Q8
- Stable Diffusion XL + ControlNet — no constraints

**Cannot run:**
- 32B models at Q4 (needs ~20GB)
- 70B models at any reasonable quality

**Best 16GB GPUs:**
- [Intel Arc A770 16GB on Amazon](https://www.amazon.com/s?k=Intel+Arc+A770+16GB&tag=kickiwebprodu-20) (~$280) — best value
- [Intel Arc B770 16GB on Amazon](https://www.amazon.com/s?k=Intel+Arc+B770+GPU&tag=kickiwebprodu-20) (~$349) — faster Battlemage
- [RTX 4060 Ti 16GB on Amazon](https://www.amazon.com/s?k=RTX+4060+Ti+16GB&tag=kickiwebprodu-20) (~$479) — best CUDA option

---

### 24GB VRAM

The frontier for consumer AI hardware in 2026. 24GB unlocks 32B models at full Q4 quality and 70B models at Q2.

**Can run:**
- DeepSeek R1 32B at Q4 (~20GB) — flagship reasoning model
- Llama 3.1 70B at Q2 (~22GB) — impressive despite compression
- DeepSeek R1 70B at Q2 (~22GB)
- Qwen 2.5 72B at Q2 (~22GB)
- Gemma 3 27B at Q5 (~21GB)
- Everything at 16GB and below

**Cannot run:**
- 70B models at Q4 (needs ~40GB)
- 405B models

**Best 24GB GPUs:**
- [Used RTX 3090 24GB on Amazon](https://www.amazon.com/s?k=RTX+3090+24GB&tag=kickiwebprodu-20) (~$475 used) — massive VRAM for budget
- [RTX 4090 24GB on Amazon](https://www.amazon.com/s?k=RTX+4090+GPU&tag=kickiwebprodu-20) (~$2,755) — fastest single consumer GPU

See the full comparison: [RTX 4090 vs RTX 3090 for Local LLMs](/guides/rtx-4090-vs-rtx-3090-for-ai)

---

### 32GB+ VRAM

Above 32GB, you're in workstation or multi-GPU territory. The RTX 5090 (32GB) sits at the edge of this tier.

**32GB (RTX 5090):**
- Llama 3.1 70B at Q4 (~38-40GB) — tight, may need 1-2 layers offloaded
- 70B at Q2/Q3 — comfortable
- Everything at 24GB tier

**48GB (dual RTX 3090 or RTX 6000 Ada):**
- Llama 3.1 70B at Q8 (~70GB) — requires dual-GPU
- DeepSeek R1 70B at Q6/Q8 — dual-GPU only
- 70B at Q4 — single 48GB card fits comfortably

**Best 32GB GPU:** [RTX 5090 32GB on Amazon](https://www.amazon.com/s?k=RTX+5090+GPU&tag=kickiwebprodu-20) (~$2,900-$3,600)

---

## What Happens When You Run Out of VRAM?

When your model exceeds available VRAM, the inference runtime has three options:

### 1. Refuse to load
Many tools fail to start if the model doesn't fit. You'll see errors like `CUDA out of memory`. This is the safest outcome.

### 2. CPU offloading (partial fit)
The excess layers run on CPU. This is the most common scenario with llama.cpp and Ollama.

**Speed impact of CPU offloading:**
- Full GPU fit: 40-120+ tok/s
- 50% offloaded: 8-15 tok/s
- 90% offloaded: 1-3 tok/s

At 1-3 tokens per second, a 200-token response takes over a minute. You'd be better off using a cloud API.

### 3. Reduce context length
A large portion of VRAM usage during inference is the **KV cache** — memory used to store previous tokens. Reducing context from 8K to 2K tokens can save 1-3GB.

In Ollama: set `OLLAMA_NUM_CTX=2048`. In LM Studio: reduce "Context Length" in model settings.

---

## VRAM by Use Case

### Coding assistant
**Recommended:** 12-16GB | **Ideal models:** DeepSeek R1 14B Q4, Qwen 2.5 14B Q4
14B code models are the sweet spot — smart enough for complex functions, fast enough for real-time completion.

### Chat / general Q&A
**Recommended:** 8-12GB | **Ideal models:** Llama 3.2 8B Q6, Mistral 7B Q8
For casual conversation, 8B models at Q6 are excellent.

### Reasoning / chain-of-thought
**Recommended:** 24GB | **Ideal models:** DeepSeek R1 32B Q4, Llama 3.1 70B Q2
Reasoning models like DeepSeek R1 shine at 32B. See the [Best GPU for DeepSeek R1 guide](/guides/best-gpu-for-deepseek-r1).

### Image generation
**Recommended:** 8GB minimum, 12-16GB ideal
SD 1.5 runs on 6GB. SDXL needs 8GB minimum, 12GB for comfortable batch generation.

### Fine-tuning / LoRA training
**Recommended:** 24GB minimum
LoRA fine-tuning of a 7B model needs ~16-20GB. See [Full Fine-Tuning vs PEFT VRAM](/guides/full-fine-tuning-vs-peft-vram) for the full breakdown.

---

## Quick Reference: VRAM vs. GPU Recommendations

| VRAM | Best Value GPU | Best CUDA GPU | Price Range |
|------|---------------|---------------|-------------|
| 8GB | RX 7600 8GB | RTX 4060 8GB | $200-$329 |
| 12GB | Arc B580 12GB | RTX 3060 12GB | $249-$299 |
| 16GB | Arc A770 16GB | RTX 4060 Ti 16GB | $280-$479 |
| 24GB | Used RTX 3090 | RTX 4090 | $475-$2,755 |
| 32GB | - | RTX 5090 | $2,900-$3,600 |
| 48GB | Dual RTX 3090 | RTX 6000 Ada | $950-$4,000+ |

> Not sure which fits your use case? [Take the 2-minute GPU Quiz](/builder)
> [Browse current GPU deals filtered by VRAM tier](/deals)

---

## FAQ

**How much VRAM do I need to run Llama 3?**
For Llama 3.2 8B, you need at minimum 6GB VRAM for Q4 quantization, but 8GB is recommended. Llama 3.1 13B needs 8GB at Q4, 12GB for Q8. Llama 3.1 70B needs 24GB at Q2 quantization or 40GB+ at Q4.

**Can I run a 70B model on a consumer GPU?**
Yes, at Q2 quantization. The RTX 3090 (24GB) and RTX 4090 (24GB) can run Llama 3.1 70B and DeepSeek R1 70B at Q2 (~22GB). For Q4 quality on 70B, you need 40GB+ — either a single 48GB workstation card or dual 24GB cards.

**Does system RAM help when VRAM runs out?**
Partially. When VRAM overflows, layers spill to system RAM — supported by llama.cpp, Ollama, and LM Studio. But system RAM bandwidth is 10-50x lower than GPU VRAM. Expect 90%+ speed drops for heavily offloaded models.

**How much VRAM do I need for DeepSeek R1?**
- DeepSeek R1 7B: 6GB (Q4), 8GB (Q8)
- DeepSeek R1 14B: 10GB (Q4), 16GB (Q8)
- DeepSeek R1 32B: 21GB (Q4), 36GB (Q8) — requires 24GB card
- DeepSeek R1 70B: 22GB (Q2), 40GB (Q4)
- DeepSeek R1 671B: 400GB+ — cloud only

Full breakdown: [Can You Run DeepSeek R1 on Your GPU?](/guides/best-gpu-for-deepseek-r1)

**Is 8GB VRAM enough for AI in 2026?**
For 7B/8B models, yes. But 8GB is increasingly the floor, not the ceiling. As 14B models become the mainstream recommendation, 8GB becomes a real limitation. Stretching to 12GB (like the Arc B580 at $249) gives much more headroom.

**Does the GPU brand matter for LLM inference?**
Less than it used to. In 2026, Nvidia (CUDA), Intel Arc (SYCL/OpenCL), and AMD (ROCm) all work with Ollama, LM Studio, and llama.cpp. Nvidia still has the most consistent ecosystem, but Intel Arc offers compelling VRAM-per-dollar value.

**What's the difference between model VRAM and total VRAM usage?**
Your GPU also uses VRAM for the OS display stack (~500MB-1GB), other applications, and the KV cache. Rule of thumb: subtract 1-2GB from your GPU's listed VRAM to get the safe working capacity. A 12GB card reliably has ~10-11GB available for model weights.

---

## Summary: The VRAM Decision Tree

1. **Running 7B/8B models only?** → 8GB is fine. 12GB is better.
2. **Want to run 13B/14B models at good quality?** → 12GB minimum, 16GB recommended.
3. **Want to run 32B models (DeepSeek R1 32B, Qwen 32B)?** → 24GB required.
4. **Want to run 70B models?** → 24GB for Q2, 40GB+ for Q4.
5. **Running image generation alongside LLMs?** → Add 2-4GB to your LLM requirement.
6. **CUDA required for your workflow?** → Nvidia only. Otherwise, Intel Arc offers better VRAM-per-dollar.

> [Browse budget GPU options by VRAM tier](/best-budget-gpu-ai-2026)
> [Take the GPU Quiz for a personalized recommendation](/builder)

*Prices accurate as of April 2026. VRAM requirements are approximate and include ~10% overhead for KV cache and runtime.*
---

### Best GPU for Local AI & LLMs in 2026
**Description:** The best GPUs for running local LLMs in 2026, ranked by budget. VRAM requirements, tokens/sec benchmarks, model compatibility, and affiliate links for every tier.

**URL:** https://aicomputerguide.com/articles/best-gpu-local-ai-llms-2026

# Best GPU for Local AI & LLMs in 2026

Running a local LLM isn't complicated, but buying the wrong GPU wastes money and leaves you unable to run the models you want. This guide covers every budget tier, from $249 entry-level cards to workstation-class 32GB monsters, with benchmark data and model compatibility tables for each. We also track prices and show the best deals based on our price tracker at [https://aicomputerguide.com/deals/](https://aicomputerguide.com/deals/).

![A diverse array of high-VRAM PC graphics cards optimized for Local AI and LLM inference](/images/guides/best-gpu-array.webp)

The short version: **VRAM determines what you can run. Speed determines how fast you run it.**

---

## At a Glance

- **Best budget pick ($249):** [Intel Arc B580](/gpu/intel-arc-b580) - 12GB VRAM, 62 tok/s on 8B models
- **Best value for VRAM ($500-$800 used):** [RTX 3090](/gpu/rtx-3090) - 24GB for the price of a mid-range card
- **Best mid-range (~$500):** [RTX 4060 Ti 16GB](/gpu/rtx-4060-ti-16gb) - 89 tok/s on 8B Q4, solid 16GB capacity
- **Best high-VRAM under $1,000:** [RX 7900 XTX](/gpu/rx-7900-xtx) - 24GB VRAM, 78 tok/s, runs 30B models
- **Best single-card for serious inference:** [RTX 4090](/gpu/rtx-4090) - 128 tok/s, 24GB, unmatched consumer speed
- **Most future-proof:** [RTX 5090](/gpu/rtx-5090) - 32GB GDDR7, 185 tok/s, runs 70B unquantized
- **The universal rule:** Prioritize VRAM over compute. A slower card with more VRAM beats a faster card that can't load your model.

---

## How Much VRAM Do You Actually Need?

Before picking a GPU, match your VRAM to your target models. This table covers the most common local LLM use cases:

| VRAM | What You Can Run | Ideal For |
|------|-----------------|-----------|
| 8GB | 7B models (Q4), 3B–7B unquantized | Quick experiments, small assistants |
| 12GB | 7B–13B (Q4/Q5), limited 20B Q2 | Most home users, coding assistants |
| 16GB | 13B–20B (Q4), 7B–13B full precision | Content generation, longer context |
| 24GB | Up to 32B (Q4), 70B (Q2–Q3) | Power users, researchers, agents |
| 32GB+ | 70B unquantized, 100B+ (Q4) | Full-scale local inference, fine-tuning |

**Key insight:** Quantization lets smaller VRAM cards punch above their weight. A 12GB card running Llama 3.1 8B at Q4 (4-bit) uses ~5GB - comfortable. The same card with a 70B Q4 model (~40GB) will crash. Know your VRAM ceiling before you buy.

---

## Best GPUs by Budget Tier

### Under $300 - Best for Getting Started

**Our Pick: Intel Arc B580 (~$249)**

The Arc B580 is the sharpest budget GPU for local AI in 2026. At $249, it delivers 12GB VRAM and **62 tok/s on 8B models** - faster than any NVIDIA card at this price point ([Compute Market, 2026](https://www.compute-market.com/blog/best-budget-gpu-for-ai-2026)).

The catch: Intel's AI stack runs on IPEX-LLM or OpenVINO rather than CUDA. Setup takes 15–30 minutes longer than NVIDIA, but once running, the performance holds up.

**Runner-up: Intel Arc A770 (~$280)**

The A770 trades slightly older architecture for **16GB VRAM** - a meaningful upgrade over 12GB at basically the same price. In benchmarks, it hits **70 tok/s on Mistral 7B** with IPEX-LLM and INT4 quantization ([DigiAlps, 2024](https://digialps.com/with-arc-a770-intel-takes-down-nvidias-value-gpu-crown-for-llms-with-a-70-performance-boost/)). The extra 4GB VRAM is worth it if you want to run 13B models without offloading.

**Safe choice: NVIDIA RTX 3060 12GB (~$279–$329)**

Slower than both Arc options on raw tok/s, but runs on CUDA - which means every tool (Ollama, LM Studio, llama.cpp GPU, Automatic1111) works out of the box, no configuration needed. Best choice if you value plug-and-play over performance.

| Card | Price | VRAM | ~Tok/s (8B) | CUDA? |
|------|-------|------|-------------|-------|
| Intel Arc B580 | $249 | 12GB | 62 | No (IPEX) |
| Intel Arc A770 | $280 | 16GB | 70 | No (IPEX) |
| RTX 3060 | $299 | 12GB | ~50 | Yes |

[Shop Intel Arc B580 on Amazon](https://www.amazon.com/s?k=intel+arc+b580&tag=kickiwebprodu-20) | [Shop RTX 3060 on Amazon](https://www.amazon.com/s?k=rtx+3060+12gb&tag=kickiwebprodu-20)

---

### $400–$700 - Best Mid-Range

**Our Pick: RTX 4060 Ti 16GB (~$450–$550)**

The RTX 4060 Ti 16GB is the sweet spot for users who want to run 13B models at full Q4 without touching CPU offload. It benchmarks at **89 tok/s on 8B Q4 models** and handles 13B comfortably within its 16GB headroom ([Core Lab, 2026](https://corelab.tech/llmgpu/)).

The 128-bit memory bus is the known weakness - bandwidth-intensive workloads don't scale as well as on wider-bus cards. But for single-user chat inference on 7B–13B models, you won't notice. CUDA compatibility means zero friction with any local LLM tool.

| Card | Price | VRAM | ~Tok/s (8B) | Runs 13B? |
|------|-------|------|-------------|-----------|
| RTX 4060 Ti 16GB | $450–$550 | 16GB | 89 | ✅ Yes |
| RTX 3060 Ti 8GB | $300–$350 | 8GB | ~60 | ❌ No |

[Shop RTX 4060 Ti 16GB on Amazon](https://www.amazon.com/s?k=rtx+4060+ti+16gb&tag=kickiwebprodu-20)

---

### $700–$1,200 - Best High-VRAM Value

**Our Pick: AMD RX 7900 XTX (~$800–$1,000)**

The RX 7900 XTX is the best VRAM-per-dollar card in this price range. **24GB VRAM** at under $1,000 - the only card in this bracket that runs 30B Q4 models without breaking a sweat. Benchmarks show **78 tok/s on Llama 3 with 33 GPU layers** ([Decode's Future, 2026](https://www.decodesfuture.com/articles/best-gpu-for-local-llms-2026-guide)).

ROCm support has matured significantly in 2025–2026. Ollama and llama.cpp both work well on ROCm; the main gaps are in fine-tuning and niche training workflows. For pure inference, this card is an exceptional value.

**Alternative: RTX 3090 (used, $712–$1,000)**

If you want CUDA + 24GB VRAM under $1,000, a used RTX 3090 delivers. You get **112 tok/s on 8B** and identical model capacity to the RTX 4090 at roughly one-third the price. See our [RTX 4090 vs RTX 3090 comparison](/rtx-4090-vs-rtx-3090-local-llms) for the full breakdown.

| Card | Price | VRAM | ~Tok/s (8B) | Runs 30B Q4? |
|------|-------|------|-------------|--------------|
| RX 7900 XTX | $800–$1,000 | 24GB | 78 | ✅ Yes |
| RTX 3090 (used) | $712–$1,000 | 24GB | 112 | ✅ Yes |
| RTX 4070 Ti Super | $800–$1,200 | 16GB | ~90 | ❌ No |

[Shop RX 7900 XTX on Amazon](https://www.amazon.com/s?k=rx+7900+xtx&tag=kickiwebprodu-20) | [Shop RTX 3090 on Amazon](https://www.amazon.com/s?k=rtx+3090&tag=kickiwebprodu-20)

---

### $1,200+ - Best High-End

**RTX 4090 (~$2,755 new)**

The fastest consumer GPU at 24GB. The RTX 4090 delivers **128 tok/s on 8B models** and **52 tok/s on Llama 3.1 70B Q4** - roughly 30% ahead of the RTX 3090 ([bestgpusforai.com, 2026](https://www.bestgpusforai.com/gpu-comparison/3090-vs-4090)). FP8 inference support and Ada Lovelace architecture make it the best single-card choice for agentic pipelines and high-throughput batch jobs.

Caveat: the current street price ($2,755+) is 71% above its $1,599 MSRP, with supply constraints expected through mid-2026. Hard to recommend over a used 3090 unless speed is genuinely critical to your workflow.

**RTX 5090 (~$2,900–$3,600 street)**

The RTX 5090 is the only consumer card with **32GB VRAM**, which unlocks 70B models at full Q4. Performance is striking: **185 tok/s on 8B models** and 15–20 tok/s on Llama 3.3 405B quantized ([RunPod, 2026](https://www.runpod.io/blog/rtx-5090-llm-benchmarks)). MSRP is $1,999, but street prices run $2,900–$3,600 due to DRAM shortages and scalping.

If you need 32GB VRAM today and can find one at or near MSRP, it's the clear top choice. At scalper prices, the math is harder.

| Card | Price | VRAM | ~Tok/s (8B) | Runs 70B Q4? |
|------|-------|------|-------------|--------------|
| RTX 4090 | ~$2,755 | 24GB | 128 | ❌ (needs Q2) |
| RTX 5090 | $2,900–$3,600 | 32GB | 185 | ✅ Yes |

[Shop RTX 4090 on Amazon](https://www.amazon.com/s?k=rtx+4090&tag=kickiwebprodu-20) | [Shop RTX 5090 on Amazon](https://www.amazon.com/s?k=rtx+5090&tag=kickiwebprodu-20)

---

## Full Comparison Table

| GPU | VRAM | ~Tok/s (8B) | Price | Best For |
|-----|------|-------------|-------|----------|
| Intel Arc B580 | 12GB | 62 | $249 | Best budget CUDA-free option |
| Intel Arc A770 | 16GB | 70 | $280 | Budget 16GB pick |
| RTX 3060 12GB | 12GB | ~50 | $299 | Budget CUDA |
| RTX 4060 Ti 16GB | 16GB | 89 | $450–$550 | Mid-range sweet spot |
| RX 7900 XTX | 24GB | 78 | $800–$1,000 | Best value 24GB |
| RTX 3090 (used) | 24GB | 112 | $712–$1,000 | Value CUDA 24GB |
| RTX 4090 | 24GB | 128 | ~$2,755 | Fastest 24GB, CUDA |
| RTX 5090 | 32GB | 185 | $2,900–$3,600 | 70B+ unquantized |

---

## Model Compatibility Guide

Can your GPU run these popular models? Here's what fits in VRAM at common quantization levels:

| Model | Q4 VRAM | Q2 VRAM | 12GB | 16GB | 24GB | 32GB |
|-------|---------|---------|------|------|------|------|
| Llama 3.1 8B | ~5GB | ~3GB | ✅ | ✅ | ✅ | ✅ |
| Mistral 7B | ~4.5GB | ~3GB | ✅ | ✅ | ✅ | ✅ |
| Llama 3.1 70B | ~40GB | ~20GB | ❌ | ❌ | ⚠️ Q2 only | ✅ |
| DeepSeek R1 7B | ~5GB | ~3GB | ✅ | ✅ | ✅ | ✅ |
| DeepSeek R1 32B | ~22GB | ~12GB | ❌ | ⚠️ Q2 only | ✅ | ✅ |
| DeepSeek R1 70B | ~40GB | ~20GB | ❌ | ❌ | ⚠️ Q2 only | ✅ |
| Qwen 2.5 72B | ~41GB | ~21GB | ❌ | ❌ | ⚠️ Q3 tight | ✅ |
| Llama 3.3 405B | ~230GB | ~115GB | ❌ | ❌ | ❌ | ❌* |

*405B requires multi-GPU or CPU offload regardless of consumer GPU tier.

**Takeaway:** 24GB VRAM is the practical ceiling for most serious local inference without multi-GPU setups. 16GB handles 90% of hobbyist workflows. 12GB is fine for 7B–8B daily drivers.

---

## FAQ

**What's the minimum GPU for running local LLMs?**
Any GPU with 8GB VRAM can run 7B models at Q4 quantization (Llama 3.1 8B, Mistral 7B). For usable speeds, aim for NVIDIA RTX 3060 or better. The Arc B580 is the best 12GB option under $250.

**Is VRAM more important than GPU speed for local LLMs?**
Yes. VRAM determines whether a model loads at all. Speed (CUDA cores, bandwidth) determines how fast tokens generate. A slower card with enough VRAM beats a faster card that can't fit your model. Always size VRAM first.

**Can AMD GPUs run local LLMs?**
Yes. ROCm support via Ollama and llama.cpp has improved significantly. The RX 7900 XTX is a genuinely competitive option for inference workloads. Fine-tuning and training workflows still favor NVIDIA for ecosystem maturity.

**Do I need a dedicated workstation GPU (A100, H100)?**
Not for home use. Consumer GPUs like the RTX 4090 and RTX 5090 match or outperform older enterprise cards (A100 SXM 40GB) on inference throughput at a fraction of the cost. Enterprise cards matter for multi-GPU NVLink setups and ECC memory reliability.

**How does quantization affect quality?**
Q4 quantization (4-bit) reduces model size by ~75% with minimal quality degradation for most use cases - typically 1–3% on benchmarks. Q2 shows more noticeable degradation on reasoning tasks. For daily chat and coding, Q4 is indistinguishable from full precision.

**Will my current PSU handle these GPUs?**
RTX 3060/Arc B580: 550W minimum. RTX 4060 Ti: 650W. RTX 3090/4090: 850W minimum, 1000W recommended. RTX 5090: 1000W minimum. Check your PSU before buying.

---

## Bottom Line

Pick the GPU that fits your VRAM requirement first, then optimize for price within that tier:

- **12GB cards** (Arc B580, RTX 3060): 7B–13B models, best for getting started
- **16GB cards** (Arc A770, RTX 4060 Ti): 13B–20B models, the practical sweet spot for most users
- **24GB cards** (RX 7900 XTX, RTX 3090 used, RTX 4090): the serious tier - runs everything up to 32B at Q4
- **32GB cards** (RTX 5090): future-proof and the only consumer option for 70B unquantized

Not sure which card fits your specific use case? Take the [GPU selector quiz](/builder) for a personalized recommendation, or check [current GPU deals](/deals) for live pricing.

---

## Sources

1. [Best Budget GPU for AI in 2026 (Compute Market)](https://www.compute-market.com/blog/best-budget-gpu-for-ai-2026)
2. [Intel Arc A770 LLM Performance Analysis (DigiAlps, 2024)](https://digialps.com/with-arc-a770-intel-takes-down-nvidias-value-gpu-crown-for-llms-with-a-70-performance-boost/)
3. [GPU Ranking for Local LLM (Core Lab, 2026)](https://corelab.tech/llmgpu/)
4. [RTX 3090 vs RTX 4090 for AI (bestgpusforai.com, 2026)](https://www.bestgpusforai.com/gpu-comparison/3090-vs-4090)
5. [Best GPU for Local LLMs 2026 Guide (Decode's Future)](https://www.decodesfuture.com/articles/best-gpu-for-local-llms-2026-guide)
6. [RTX 5090 LLM Benchmarks (RunPod, 2026)](https://www.runpod.io/blog/rtx-5090-llm-benchmarks)
7. [Local AI Hardware Requirements 2026 (Local AI Master)](https://localaimaster.com/blog/ai-hardware-requirements-2025-complete-guide)

---
---

### RTX 4090 vs RTX 3090 for Local LLMs — Which Should You Buy in 2026?
**Description:** RTX 4090 vs RTX 3090 for local LLMs: head-to-head benchmarks, VRAM analysis, price comparison, and a clear verdict on which 24GB GPU is worth your money in 2026.

**URL:** https://aicomputerguide.com/articles/rtx-4090-vs-rtx-3090-for-ai

# RTX 4090 vs RTX 3090 for Local LLMs — Which Should You Buy in 2026?

Both cards pack 24GB of VRAM. Both run the same models. The RTX 4090 costs nearly twice as much. Here's whether that gap is worth it for running Llama, DeepSeek, and friends at home.

![Comparison chart and hardware setup measuring Nvidia RTX 4090 versus RTX 3090 inference tokens per second](/images/guides/rtx-3090-vs-4090-chart.webp)

---

## At a Glance

- **Same model capacity:** Both have 24GB VRAM — you run identical model sizes on either card
- **RTX 4090 is ~30% faster:** 128 tok/s vs 112 tok/s on 8B models; 52 vs 42 tok/s on 70B Q4 ([bestgpusforai.com, 2026](https://www.bestgpusforai.com/gpu-comparison/3090-vs-4090))
- **RTX 4090 price:** ~$2,755 new on Amazon — 71% above its original $1,599 MSRP
- **RTX 3090 price:** $712–$1,000 used, ~$1,488 new ([bestvaluegpu.com, 2026](https://bestvaluegpu.com/history/new-and-used-rtx-3090-price-history-and-specs/))
- **Power gap:** 450W (4090) vs 350W (3090) — that extra 100W adds up over time
- **Verdict:** RTX 3090 used wins on value for most home users; RTX 4090 is for speed-first workflows with budget to spare

---

## Specs Comparison

| Spec | RTX 4090 | RTX 3090 |
|---|---|---|
| VRAM | 24GB GDDR6X | 24GB GDDR6X |
| CUDA Cores | 16,384 | 10,496 |
| Tensor TFLOPs | 660 | ~285 |
| L2 Cache | 72MB | 6MB |
| TDP | 450W | 350W |
| MSRP (launch) | $1,599 | $1,499 |
| Current new price | ~$2,755 | ~$1,488 |
| Current used price | N/A | $712–$1,000 |

The 4090's architectural lead is substantial on paper: 56% more CUDA cores, 12x the L2 cache, and 2.3x the Tensor throughput. In practice, LLM inference doesn't saturate all of that — but the gap does show up in real benchmarks.

---

## Performance: Tokens Per Second

Raw inference speed is where the RTX 4090 earns its premium. In LLM benchmarks ([hardware-corner.net, 2026](https://www.hardware-corner.net/rtx-4090-llm-benchmarks/)):

- **8B models (Llama 3, Mistral):** RTX 4090 — 128 tok/s | RTX 3090 — 112 tok/s
- **Llama 3.1 70B Q4:** RTX 4090 — 52 tok/s | RTX 3090 — 42 tok/s
- **Median improvement across 8 benchmarks:** 4090 leads by 16–40% depending on model and quantization

At 52 tok/s on 70B Q4, the 4090 feels like a fast local chat session. At 42 tok/s, the 3090 is still perfectly usable — responses appear faster than you read them. The real-world feel difference is meaningful for high-throughput batch jobs, but barely noticeable for single-user chat.

Where the 4090 pulls ahead more noticeably: long-context workloads and FP8 inference. The Ada Lovelace architecture supports FP8 natively; the 3090 doesn't. If you're running TensorRT-LLM or targeting inference optimization stacks that exploit FP8, the 4090's advantage widens.

---

## VRAM: What Can You Actually Run on 24GB?

Since both cards share the same 24GB ceiling, model compatibility is identical. Here's what fits:

| Model | VRAM Required | Fits on 24GB? |
|---|---|---|
| Llama 3.1 8B (Q4) | ~5GB | ✅ Yes |
| Mistral 7B (Q4) | ~4.5GB | ✅ Yes |
| Llama 3.1 70B (Q4) | ~40GB | ❌ No (needs 2× GPU or CPU offload) |
| Llama 3.1 70B (Q2) | ~20GB | ✅ Yes |
| DeepSeek R1 7B | ~5GB | ✅ Yes |
| DeepSeek R1 32B (Q4) | ~22GB | ✅ Yes |
| DeepSeek R1 70B (Q4) | ~40GB | ❌ No |
| Qwen 2.5 72B (Q3) | ~24GB | ✅ Tight fit |

The 24GB sweet spot lands on everything up to 32–34B at Q4, plus quantized 70B models. Neither card gives you a capacity edge here — if a model runs on one, it runs on the other. VRAM is the constraint; compute speed is not.

---

## Price & Value: The Decisive Factor

This is where the comparison gets stark.

The RTX 4090 currently trades at **$2,755 new** on Amazon — 71% above its launch price, with supply constraints expected to push prices another 10–20% higher through mid-2026 ([gpudeals.net, 2026](https://gpudeals.net/gpus/rtx-4090.html)). There's no meaningful used market for 4090s.

The RTX 3090 tells a different story:

- **New:** ~$1,488 (essentially at original MSRP)
- **Used:** $712–$1,000 — validated by multiple marketplaces

A used 3090 at $800 vs a new 4090 at $2,755 means you're paying **3.4× more for ~30% more speed**. In raw terms, the 4090 delivers roughly 0.9% more performance per dollar spent. The 3090 used wins this calculation by a wide margin.

The one exception: if you're running a multi-GPU inference server, the 4090's better memory bandwidth and FP8 support change the calculus. For a single-card home build, the math doesn't support the premium.

---

## Power Draw: The Hidden Monthly Cost

Both cards are power-hungry, but the gap matters at the budget level.

| | RTX 4090 | RTX 3090 |
|---|---|---|
| TDP | 450W | 350W |
| Extra watts vs baseline | +100W | — |
| Extra kWh/year (8hr/day) | +292 kWh | — |
| Extra annual cost (at $0.15/kWh) | ~$44/year | — |

An extra $44/year sounds minor. Over three years of daily use, that's $130 — which buys a decent NVMe drive or helps cover a PSU upgrade. If you're in a region with higher electricity rates (say $0.30/kWh), that gap doubles to ~$88/year.

You also need a beefier PSU for the 4090. NVIDIA recommends 850W minimum; most builders target 1000W for headroom. If you're upgrading from a 750W unit, factor in that cost too.

---

## Which Should You Buy?

Use this decision matrix:

**Buy the RTX 3090 (used) if:**
- Budget is under $1,500
- You primarily run chat/inference (not batch processing)
- You want the best dollar-per-performance ratio
- You're fine running models up to ~32B Q4 with excellent speed

**Buy the RTX 4090 if:**
- Speed is your top priority and budget isn't the constraint
- You're running FP8 inference or TensorRT-LLM workloads
- You plan to run high-throughput batch jobs (multiple requests, agentic pipelines)
- You want a card that won't need replacing for 5+ years

**Neither card makes sense if:**
- You need more than 24GB VRAM (look at RTX 5090 at 32GB, or dual-GPU setups)
- You're on a tight budget (RTX 3060 12GB at ~$300 runs 7–13B models fine)

---

## FAQ

**Can the RTX 3090 still keep up in 2026?**
Yes, for most home users. Its 24GB VRAM and ~112 tok/s on 8B models make it more than capable for chat, coding assistants, and local inference. The architecture is older, but LLM inference workloads don't require bleeding-edge compute.

**Is the RTX 3090 reliable to buy used?**
Generally yes. Most used 3090s on the market came from gaming or crypto mining rigs, not heavy AI workloads. Check for temperature records if the seller provides them, and buy from reputable resellers with return policies. The card's longevity track record is strong.

**Does the RTX 4090 support any models the 3090 can't run?**
No — both max out at 24GB VRAM, so model compatibility is identical. The 4090 runs those models faster, not larger.

**What about the RTX 5090?**
The RTX 5090 offers 32GB VRAM, which unlocks unquantized 70B models and larger 32B variants. At ~$2,000+ current pricing, it's a strong alternative to the 4090 for future-proofing. See our [GPU deals page](/deals) for current pricing.

**Which should I buy for DeepSeek R1?**
Both run DeepSeek R1 32B Q4 comfortably within 24GB. The 4090 generates responses faster, but the 3090's output is still ahead of real-time reading speed. For DeepSeek R1 70B, you'll need quantization (Q2–Q3) on either card.

---

## Bottom Line

The RTX 3090 and RTX 4090 are the only consumer GPUs with 24GB VRAM outside of workstation cards — and that shared ceiling means they run the same models. The difference is speed and price.

At current market rates, the 3090 used offers **3–4× better value per dollar** for local LLM inference. The 4090 is faster — ~30% across most workloads — but that premium is priced at 3.4× the cost of a quality used 3090.

For most home builders, the used RTX 3090 is the call. If you're building a high-throughput inference server or just want the fastest single-GPU setup available at 24GB, the 4090 is the clear winner — assuming you can swallow the markup.

Not sure which GPU fits your specific setup? Take our [GPU selector quiz](/builder) or check the latest [GPU deals](/deals) for current pricing.

---

## Affiliate Links

- [RTX 4090 on Amazon](https://www.amazon.com/s?k=rtx+4090&tag=kickiwebprodu-20)
- [RTX 3090 on Amazon](https://www.amazon.com/s?k=rtx+3090&tag=kickiwebprodu-20)

---

## Sources

1. [RTX 3090 vs RTX 4090 for AI — Performance & Upgrade Analysis (bestgpusforai.com, 2026)](https://www.bestgpusforai.com/gpu-comparison/3090-vs-4090)
2. [RTX 4090 LLM Benchmarks: 4K–131K Context (hardware-corner.net, 2026)](https://www.hardware-corner.net/rtx-4090-llm-benchmarks/)
3. [RTX 4090 Price History & Specs (bestvaluegpu.com, 2026)](https://bestvaluegpu.com/history/new-and-used-rtx-4090-price-history-and-specs/)
4. [RTX 3090 Price History & Specs (bestvaluegpu.com, 2026)](https://bestvaluegpu.com/history/new-and-used-rtx-3090-price-history-and-specs/)
5. [RTX 4090 Deals (gpudeals.net, 2026)](https://gpudeals.net/gpus/rtx-4090.html)
6. [Used RTX 3090 — Value King for Local AI (xda-developers.com, 2026)](https://www.xda-developers.com/used-rtx-3090-still-best-for-local-ai-in-value/)

---
---

### Best GPU for DeepSeek R1: The Ultimate VRAM Guide
**Description:** DeepSeek R1 requires massive VRAM for native inference. Learn how quantization, FP8 precision, and CUDA cores impact performance.

**URL:** https://aicomputerguide.com/articles/best-gpu-for-deepseek-r1

The release of DeepSeek R1 has fundamentally shifted the landscape of local AI. While previous massive models required enterprise-level server racks, advancements in [Quantization](/glossary/quantization) and precision management have made it possible for prosumers to run this behemoth at home. However, make no mistake: DeepSeek R1 is a giant, and feeding it requires an enormous amount of highly optimized memory. 

In this comprehensive guide, we will break down the exact hardware requirements, explain why [VRAM](/glossary/vram) dictates everything, and explore why the [NVIDIA RTX 5090](/gpu/rtx-5090) and dual-GPU setups have become the gold standard for native inference.

## The Architecture of DeepSeek R1

To understand the hardware requirements, we first need to understand what makes DeepSeek R1 unique. Unlike older monolithic models, modern massive LLMs often utilize Mixture of Experts (MoE) architectures, which handle routing logic contextually. While this speeds up the forward pass significantly (because only a subset of parameters is active at any given time), every single parameter must still reside in your active memory pool to prevent catastrophic slowdowns.

DeepSeek R1, at its full uncompressed size (FP16), is over 600GB. Obviously, running this locally on consumer hardware is impossible. The solution? Deep quantization. 

### Why Quantization Matters

When we talk about running DeepSeek locally, we are almost always talking about the **4-bit quantized version (Q4_K_M)** or similar aggressive quantizations. 

- **Full Precision (FP16):** ~600GB VRAM required.
- **8-bit Quantization (Q8_0):** ~300GB VRAM required.
- **4-bit Quantization (Q4_K_M):** ~40GB to 45GB VRAM required.
- **Lower Precision (IQ2_XXS):** ~20GB to 25GB VRAM.

Even at 4-bit, the model requires a baseline of roughly 40GB+ of VRAM just to load the weights. This doesn't even account for the KV Cache (the memory required to remember the ongoing conversation) or the context window. 

## The VRAM Wall: Why a Single Card Isn't Enough

Let's look at the current flagship consumer card: the [NVIDIA RTX 5090](/gpu/rtx-5090). It sits at the absolute pinnacle of the [Best GPUs for AI in 2026](/), boasting an incredible 32GB of high-speed GDDR7 memory. 

If DeepSeek R1 (at 4-bit) requires ~40GB, and the RTX 5090 provides 32GB, we have an 8GB shortfall. In standard PC gaming, a VRAM shortfall means some stuttering. In local AI inference, a VRAM shortfall is a cliff. 

When a model cannot fit entirely into VRAM, the inference engine (like [Ollama](/models/ollama) or LM Studio) must offload the remaining layers to your system RAM. System RAM runs at roughly 50-80 GB/s (for DDR5), whereas the RTX 5090's GDDR7 VRAM runs at nearly 1,800 GB/s. Offloading just a few gigabytes to system RAM can reduce your tokens-per-second generation speed by over 90%, transforming an instant stream of text into a crawling, painful reading experience.

### The Solution: Multi-GPU Scaling

To run DeepSeek R1 effectively, you must eliminate system RAM offloading. This requires combining the VRAM pools of multiple graphics cards. 

**Option 1: Dual RTX 4090s (48GB Total VRAM)**
The [NVIDIA RTX 4090](/gpu/rtx-4090), with its 24GB of GDDR6X memory, was the previous generation's king. Two of these paired together via a standard PCIe riser setup yield 48GB of VRAM. This is enough to comfortably hold a 4-bit quantized DeepSeek R1 with several gigabytes leftover for a massive context window. 

**Option 2: The RTX 5090 + Secondary Card (48GB+ Total VRAM)**
A common high-end configuration in 2026 is utilizing the massive bandwidth of an [RTX 5090](/gpu/rtx-5090) (32GB) alongside a secondary card like the [RTX 5070 Ti](/gpu/rtx-5070-ti) (16GB) or even a [RTX 4080 Super](/gpu/rtx-4080-super) (16GB). This yields 48GB+ of VRAM. Because the 5090 handles the bulk of the fast matrix multiplication, you reap the benefits of Blackwell's architecture while using the secondary card purely as high-speed storage for the remaining model layers.

## Blackwell's Secret Weapon: FP8 Precision

So, why buy an RTX 5090 if two older RTX 4090s or even three [RTX 3090s](/gpu/rtx-3090) offer more VRAM for less money? The answer lies in the **Blackwell Architecture**.

NVIDIA's 50-series cards introduced drastically improved [FP8 and FP4](/glossary/fp-8-fp-4) support natively on the tensor cores. Older cards treat 8-bit matrices as a fallback or handle them less efficiently. The RTX 5090 is built from the ground up to consume heavily quantized models. 

When running highly compressed models, the overhead from constant de-quantization (unpacking the mathematics to execute them) eats into your CUDA cores. The RTX 5090's 5th Gen Tensor Cores accelerate this inherently. 

Furthermore, the leap to **GDDR7 memory** changed everything. Operating at nearly 1.8 TB/s, the RTX 5090 can fetch and serve tokens to the processor exponentially faster than the 4090. If you pair a 5090 with a secondary card, the sheer speed at which the 5090 calculates its 32GB chunk completely masks the slight latency of the secondary PCIe bus interactions.

## How to Build a DeepSeek R1 Workstation

If you are planning to build a local workstation specifically to conquer massive models like DeepSeek, you need to think beyond just the GPU. Here is what an Elite Workstation requires:

1. **Power Supply (PSU):** A dual-GPU setup requires immaculate power delivery. The RTX 5090 pulls over 500W alone. If pairing it with an older 4090, you need a minimum of 1600W. For dual 50-series cards, a highly rated unit like the [Corsair RM1000x](/gpu/corsair-rm1000x) or above is absolutely mandatory. AI inference causes massive transient spikes that will trip a weak PSU.
2. **Motherboard & PCIe Lanes:** Most consumer motherboards throttle the second GPU to PCIe x4 speeds when two cards are inserted. While this doesn't hurt raw VRAM capacity, it slightly slows down layer routing. If possible, look for HEDT (High-End Desktop) platforms like Threadripper, or simply accept the minor bottleneck of an x8/x8 desktop board.
3. **RAM & CPU:** Even if the model sits in VRAM, your CPU must pre-process the prompt before sending it to the GPU. A fast processor with DDR5-6000+ system memory is vital for the initial "Time to First Token."

## Conclusion: Is DeepSeek Worth the Hardware Cost?

If you are a developer, an enterprise trying to avoid the "Token Tax" of cloud APIs, or a researcher needing absolute data privacy, building a 48GB+ rig to run DeepSeek R1 locally is an incredibly fast ROI. 

While the [Llama 3.3 Hardware Requirements](/guides/llama-3-3-hardware-requirements) are significantly lower, DeepSeek R1 offers nuance and logic reasoning capabilities that rival the best closed-source models in the world. By investing in a high-[VRAM](/glossary/vram) Nvidia ecosystem, particularly leveraging the Blackwell 50-series, you are guaranteeing yourself a private, uncensored supercomputer that will remain aggressively relevant for years to come. Utilize our [Will It Run?](/tools/will-it-run) calculator to pinpoint your exact VRAM needs before making a purchase.

---

### Llama 3.3 Hardware Requirements: What You Actually Need
**Description:** Everything you need to know about running Llama 3.3 locally, from VRAM capacity to system memory overhead.

**URL:** https://aicomputerguide.com/articles/llama-3-3-hardware-requirements

Llama 3.3 70B has established itself as the true "sweet spot" for local AI inference. It strikes an improbable balance: offering reasoning capabilities that rival massive proprietary cloud models while remaining just small enough to run on high-end consumer hardware. But exactly what hardware do you need? 

In this exhaustive guide, we will break down the precise [VRAM](/glossary/vram) requirements, explain how different quantization levels impact your memory footprint, and provide clear hardware recommendations, from the [RTX 5090](/gpu/rtx-5090) down to budget-friendly multi-[AMD](/gpu/rx-9070) setups.

## Understanding the True Size of 70B Models

The "70B" in Llama 3.3 means the model contains roughly 70 billion parameters. In its native, uncompressed 16-bit floating-point (FP16) state, you can calculate the baseline VRAM requirement with simple math: 70 billion parameters × 2 bytes per parameter = **140GB of VRAM**.

Obviously, you are not buying an 8-GPU server rack for your living room. To run this at home, we rely on [Quantization](/glossary/quantization) — the mathematical art of compressing parameters from 16-bit numbers down to 8-bit, 4-bit, or even 2-bit approximations. 

### The 4-Bit Standard (GGUF/EXL2)

For the vast majority of local AI enthusiasts, 4-bit quantization (such as Q4_K_M in the GGUF format or 4.0bpw in EXL2) is the golden standard. At 4-bit, you experience less than a 2% degradation in the model's intelligence, while drastically shrinking its footprint.

At 4-bit, Llama 3.3 roughly requires:
- **Model Weights:** ~40GB of VRAM just to load the core file.
- **Context Window / KV Cache:** ~2GB to 8GB of VRAM, depending on how much history you want the model to remember during the chat.
- **Total Comfort Zone:** ~48GB of VRAM for flawless, lightning-fast inference.

Wait — doesn't the [NVIDIA RTX 5090](/gpu/rtx-5090) only have 32GB of VRAM? Yes. And this is where hardware strategy becomes critical.

## Strategy 1: The "Elite" Single GPU + System Offload
If you own a flagship [RTX 5090 (32GB)](/gpu/rtx-5090) or an older [RTX 4090 (24GB)](/gpu/rtx-4090), you cannot fit the entirely of a 4-bit Llama 3.3 into your graphics card. 

The inference engine (like [Ollama](/models/ollama) or LM-Studio) will automatically load 32GB of the model into your lightning-fast GDDR7 VRAM, and "offload" the remaining 10GB+ to your regular system RAM (DDR5).

**The Result:** Because the RTX 5090 processes its portion of the data so incomprehensibly fast (at nearly 1.8 TB/s bandwidth), the penalty of offloading the final layers to system RAM is somewhat masked. You will still achieve very readable generation speeds (often 8 to 15 tokens per second), but your CPU and system RAM must be fast. An [Intel Core i9-14900K](/gpu/intel-i9-14900k) with DDR5-6400+ is highly recommended if you plan to rely on system RAM offloading. 

## Strategy 2: The Multi-GPU Approach (Zero Offloading)
If you want blistering, instantaneous generation speeds (25+ tokens per second), you must embrace the "Zero Offload" philosophy. Every single layer of the model must reside in VRAM.

To hit the 48GB target, you need multiple cards. Because inference routing is linear (the data literally travels from Card 1, finishes its math, and goes to Card 2), you **do not** need NVLink, SLI, or matched cards. You just need PCIe slots and a massive [Corsair RM1000x](/gpu/corsair-rm1000x) PSU.

**Popular Multi-GPU Combinations:**
- **The "Used Market Special":** Two [RTX 3090s](/gpu/rtx-3090). (24GB + 24GB = 48GB). This is the cheapest way to achieve native 70B inference. 
- **The "Modern Flex":** One [RTX 5080](/gpu/rtx-5080) (16GB) + One [RTX 5090](/gpu/rtx-5090) (32GB) = 48GB. 
- **The "Budget Red Team":** Three [AMD Radeon RX 9070s](/gpu/rx-9070) (16GB + 16GB + 16GB = 48GB). While Rocm (AMD's AI software stack) is slightly harder to set up, getting 48GB of VRAM for around $1,500 is an unbeatable value.

## Strategy 3: Extreme Quantization (IQ2 / 2.5-Bit)
What if you refuse to build a multi-GPU rig and want to run Llama 3.3 entirely inside the VRAM of a single [RTX 5090](/gpu/rtx-5090)? 

Enter the extreme "I-Quants" (Imatrix Quantizations). By compressing the model down to ~2.5 bits per parameter (IQ2_M or IQ2_S), the total model size shrinks to roughly **26GB**. 

When you load a 26GB model into the RTX 5090's 32GB VRAM pool, you are left with ~6GB of VRAM specifically dedicated to the KV Cache. This allows you to process entire PDFs or long codebases instantly.

**Is there a catch?**
Yes. At 2.5-bit quantization, Llama 3.3 begins to lose some of its nuanced reasoning capabilities. It is still brilliant, but it may struggle slightly with highly complex logic puzzles or dense coding architectures compared to its 4-bit counterpart. However, the speed of executing a model entirely inside GDDR7 memory is breathtaking—expect speeds north of 40 tokens per second!

## Don't Forget the Mac Studio
It is impossible to talk about Llama 3.3 without mentioning the [Apple Mac Studio (M4 Max)](/gpu/mac-studio-m4-max). Apple silicon uses "Unified Memory." If you buy a Mac with 64GB or 128GB of Unified Memory, the GPU has direct, high-bandwidth access to all of it. A 128GB Mac Studio can swallow a 4-bit Llama 3.3 effortlessly, running it entirely in VRAM with zero PCIe bottlenecking. While raw tokens-per-second might be slightly slower than dual NVIDIA cards, the simplicity and power efficiency are unmatched.

## Conclusion 
Llama 3.3 is the ultimate daily driver for the local AI enthusiast. If you are serious about privacy and capability, targeting a **48GB VRAM pool** across multiple used [RTX 3090s](/gpu/rtx-3090) or a mix of modern 50-series cards is the definitive path forward. If you are constrained to a single card, the [RTX 5090](/gpu/rtx-5090) combined with IQ2 quantization provides a stunning, premium experience that easily offsets cloud API costs within months. 

Explore our [AI Computer Builder](/builder) to mock up your perfect Llama 3.3 rig today.

---

### Stable Diffusion XL: Does VRAM Capacity Affect Speed?
**Description:** In image generation, VRAM affects batch size and resolution. We compare RTX 4090 vs RTX 5080.

**URL:** https://aicomputerguide.com/articles/stable-diffusion-xl-vram-vs-speed

Stable Diffusion XL (SDXL) represents a significant leap from the older, lighter SD 1.5 models. With much larger parameter counts and significantly more complex attention mechanism architectures, rendering stunning images locally demands more from your hardware than ever before. But a common question persists in the community: *Does having more VRAM actually make my images generate faster?*

The short answer is no, but the long answer is: it absolutely dictates your workflow. In this in-depth guide, we will analyze the relationship between [VRAM](/glossary/vram), Memory Bandwidth, and CUDA cores, and how choosing between cards like the [RTX 4090](/gpu/rtx-4090) and the newer [RTX 5080](/gpu/rtx-5080) impacts your localized Stable Diffusion Studio.

## Mythbusting: VRAM Does Not Equal Speed

There is a persistent myth that a card with 24GB of VRAM will inherently render a 1024x1024 image "faster" than a card with 16GB of VRAM. This is biologically false.

VRAM (Video Random Access Memory) is a storage desk. Think of it as the physical surface area you have to work on. If your project (the model weights + the latent image size) is 12GB large, both the 16GB desk and the 24GB desk have enough room to fit the project perfectly. Therefore, simply having more empty space left over on the desk does not speed up the drawing process.

The actual *speed* of image generation—measured in "iterations per second" (it/s)—is determined by two completely different hardware specifications:
1. **CUDA Cores / Compute Capability:** The tiny workers actually performing the mathematical diffusion logic.
2. **Memory Bandwidth:** How fast those workers can pull data off the desk and put it back. 

## So Why Buy High VRAM Cards for SDXL?

If VRAM doesn't dictate speed, why are artists constantly striving to buy cards like the [NVIDIA RTX 5090 (32GB)](/gpu/rtx-5090) or hunting for used [RTX 3090s (24GB)](/gpu/rtx-3090)?

Because VRAM dictates **scale, batch size, and capability.**

### 1. High-Resolution Up-scaling
SDXL is natively trained to output 1024x1024 images. A modern [16GB card](/gpu/rtx-5070-ti) handles this with extreme ease. However, AI workflows rarely stop at 1024. Most users utilize high-resolution fixes (Hi-Res Fix) or latent upscalers like ControlNet Tile to push images to 4K or 8K resolution.

When you double an image's resolution, the pixel grid quadruples in size. The mathematical tensors expand exponentially. A 16GB card will abruptly crash with an "Out of Memory" (OOM) error if you attempt a massive 3x upscale in a single pass. A 24GB or 32GB card provides the massive overhead required to hold those immense latent tensors without crashing.

### 2. Batch Sizes
If you are iterating on a design, rendering 8 images simultaneously (a batch size of 8) is highly efficient. Every image added to the batch parallelizes the workload but linearly increases the VRAM requirement. With an [RTX 5090](/gpu/rtx-5090), you can process massive batches in the same time a 12GB card processes two, essentially acting as an incredible multiplying force for your workflow efficiency.

### 3. Running Multiple LoRAs and ControlNets
Standard prompt engineering is dead. Modern workflows rely on chaining multiple highly specific models together. You might have the base SDXL model loaded, three stylistic LoRAs (Low-Rank Adaptations), a ControlNet for pose detection, and an IP-Adapter for face consistency. 

Every single one of these auxiliary networks requires an absolute chunk of VRAM. If you are using a budget [12GB card](/gpu/rtx-3060-12gb), you will constantly be shuffling networks in and out of VRAM (a desperately slow process), whereas a heavy-VRAM card simply holds them all in memory simultaneously, allowing instant, real-time generation updates.

## The RTX 50-Series Memory Bandwidth Advantage

While VRAM capacity hasn't jumped massively across the mid-tier between generations, the new Blackwell 50-series cards introduced **GDDR7 memory**. 

This is where speed suddenly jumps back into the conversation. Models like Stable Diffusion heavily rely on "memory bound" operations during the attention calculations. The [RTX 5080](/gpu/rtx-5080), despite only having 16GB of VRAM (the same capacity as the older [4070 Ti Super](/gpu/rtx-4070-ti-super)), processes images significantly faster. 

Why? Because its 960 GB/s bandwidth ferries mathematical updates to the GPU die almost 30% faster than older memory architectures. 

## Training Your Own LoRAs: The Ultimate VRAM Test

The most important consideration when planning your SDXL rig is whether you intend to *generate* art, or *train* your own styles. 

Training a LoRA on SDXL requires calculating gradients—the "learning" part of the AI. Gradients are massive mathematical state files that sit alongside the model. 

- **Fine-tuning SD 1.5:** Requires roughly 8GB to 10GB of VRAM.
- **Fine-tuning SDXL:** Requires an absolute minimum of **16GB of VRAM**, with 24GB highly recommended for optimal batch sizes and higher learning rates.

If you plan on training your own concepts, styles, or inserting specific products into an AI model, a 12GB card will brutally limit/prevent you from accessing SDXL trainers. You **must** prioritize cards like the [RX 9070 XT](/gpu/rx-9070-xt) or [RTX 4090](/gpu/rtx-4090).

## Verdict: Balancing Cost and Capability

When planning an AI image generation PC, evaluate your actual workflow. 
If you are simply prompting for fun at 1024x1024, an [RTX 5070](/gpu/rtx-5070) or a budget [RTX 3060 12GB](/gpu/rtx-3060-12gb) offers staggering value. 

But if you are a professional designer trying to embed specific control networks, scale up to 4K print-ready resolutions, and generate massive variant batches, VRAM is the oxygen your workflow needs to breathe. Target a 24GB or 32GB ecosystem. Use our [Will It Run?](/tools/will-it-run) calculator to input your exact SDXL stack and see precisely how close you are to the OOM cliff edge.

---

### Fine-tuning 8B Models on a Budget: 16GB is the Key
**Description:** Learn why the AMD RX 9070 and RTX 5070 Ti are great for entry-level model fine-tuning.

**URL:** https://aicomputerguide.com/articles/fine-tuning-8b-models-on-a-budget

Fine-tuning your own localized AI models is no longer locked behind enterprise hardware. While full-parameter fine-tuning remains computationally oppressive, advancements in [PEFT](/guides/full-fine-tuning-vs-peft-vram) (Parameter-Efficient Fine-Tuning) have completely democratized AI training for the home user. However, one hard truth remains: fine-tuning requires significantly more [VRAM](/glossary/vram) than simple inference.

This brings us to the modern prosumer dilemma: How do you build a workstation capable of fine-tuning an 8B model (like Llama 3 8B) without spending $2,000 on a flagship [RTX 5090](/gpu/rtx-5090)? The answer, universally, is 16GB of VRAM.

In this deep dive, we explore why 16GB is the absolute baseline for custom model creation, and we pit the two greatest budget workstation GPUs against each other: the [NVIDIA RTX 5070 Ti](/gpu/rtx-5070-ti) and the [AMD Radeon RX 9070](/gpu/rx-9070).

## The Mathematics of 8B Model Training
To understand why a 12GB budget card like the [RTX 3060 12GB](/gpu/rtx-3060-12gb) falls frustratingly short for comprehensive training, we must break down the VRAM allocation during a [QLoRA](/guides/mastering-qlora-for-8b-models) (Quantized Low-Rank Adaptation) fine-tuning run on an 8-Billion parameter model.

When you commence training, your VRAM is divided into several strict buckets:
1. **Model Weights (4-bit Quantized):** ~5.5GB to 6GB of VRAM.
2. **LoRA Adapters:** ~300MB to 1GB (depending on your Rank and Alpha settings).
3. **Gradients (The "Learning" State):** ~1GB to 2GB.
4. **Optimizer States:** ~2GB (e.g., AdamW8bit).
5. **Activations (Batch Processing):** ~4GB to 8GB, scaling aggressively with sequence length and batch size.

If you attempt to train Llama 3 8B with a standard 8k context window on a 12GB card, you will immediately hit an "Out of Memory" (OOM) error unless you drastically cripple your sequence length (the amount of text the model can 'read' while learning) down to roughly 512 tokens. 

Reducing the sequence length destroys the model's ability to learn long-form context, effectively ruining the fine-tuning for tasks like coding or creative writing. 

16GB of VRAM provides the golden cushion. It allows for robust 4k or 8k sequence lengths, moderate batch sizes, and the use of full [Unsloth frameworks](/guides/unsloth-2x-training-speedup) without crashing. 

## The NVIDIA Option: RTX 5070 Ti (16GB)
NVIDIA holds a virtual monopoly on the AI training ecosystem due to **CUDA**. Almost all major Python libraries (PyTorch, TensorFlow, Hugging Face Transformers) are built natively on CUDA architecture. 

The [RTX 5070 Ti](/gpu/rtx-5070-ti) is arguably the strongest mid-range training card in the world right now. 
It offers exactly 16GB of incredibly fast **GDDR7 memory**, providing 896 GB/s of bandwidth. More importantly, it features NVIDIA's 5th Generation Tensor Cores, which natively support [FP8 Precision](/glossary/fp-8-fp-4) training. 

If you are a beginner, or if you simply want a seamless "plug and play" experience where every GitHub repository you clone instantly works without troubleshooting compilers, you absolutely must stick to NVIDIA. The $899 price tag of the 5070 Ti is steep for a mid-range naming convention, but in terms of AI workflow efficiency, it pays for itself within weeks.

## The Alternative "Red Team" Strategy: AMD Radeon RX 9070 (16GB)
For years, local AI enthusiasts ignored AMD. However, with the release of the [RX 9070](/gpu/rx-9070) and AMD's massively improved **ROCm (Radeon Open Compute) ecosystem**, the paradigm has shifted.

The RX 9070 provides the holy grail of 16GB VRAM for under $500. It is a stunning, disruptive price-to-VRAM ratio. 

**The Caveats of Choosing AMD:**
While PyTorch now natively supports ROCm, running complex Unsloth training scripts or specialized Flash Attention optimizations often requires hunting down specific forks or troubleshooting environmental variables on Linux. (ROCm on Windows is currently deeply inferior to Linux counterparts). If you are technically savvy, comfortable living in Ubuntu terminal windows, and want to save $400, the [RX 9070](/gpu/rx-9070) or the slightly faster [RX 9070 XT](/gpu/rx-9070-xt) is an undeniable bargain.

However, be aware that your training runs will take slightly longer. The raw matrix computing power of AMD's RDNA 4 architecture simply cannot match the optimized throughput of NVIDIA's Tensor cores in deep learning benchmarks. But remember: training is a background task. If a training epoch takes 40 minutes on AMD instead of 25 minutes on NVIDIA, but costs thousands less than the [Elite Workstation](/builds/elite), the value proposition remains high.

## What about Used Hardware?
If both $500 and $900 are too expensive for your budget build, the absolute best alternative is the used market. 

The [RTX 4080 Super](/gpu/rtx-4080-super) frequently hits the second-hand market around $700, offering 16GB of VRAM and blistering CUDA performance. Better yet, the older 30-series occasionally provides amazing deals on highly capable hardware. A heavily used [RTX 3090](/gpu/rtx-3090) gives you 24GB of VRAM—the ultimate training luxury—for roughly the same price as a brand-new 5070 Ti.

## Conclusion: Plan for the Frameworks
Fine-tuning 8B-tier local AI models at home is perfectly viable on budget-friendly hardware. The hard stop is the 16GB VRAM threshold. 

If you want the path of least resistance, standardizing on NVIDIA's CUDA architecture via the [RTX 5070 Ti](/gpu/rtx-5070-ti) guarantees you won't lose days to frustrating environmental configuration bugs. If you operate exclusively in Linux and enjoy extreme value engineering, the [AMD Radeon RX 9070](/gpu/rx-9070) unlocks that critical 16GB barrier at the lowest possible cost currently on the market. Always use our built in [Hardware Comparison matrix](/tools/gpu-compare) to check your local prices before pulling the trigger!

---

### NVIDIA RTX 5090 Blackwell: The New AI Standard
**Description:** The RTX 5090 is officially here. We break down its performance for local LLM inference and training.

**URL:** https://aicomputerguide.com/articles/rtx-5090-blackwell-ai-benchmark

For the past two years, the NVIDIA RTX 4090 represented the absolute pinnacle of consumer AI hardware. With 24GB of high-speed VRAM and an army of CUDA cores, it became the mandatory foundation for small enterprise and serious prosumer local AI development. 

Now, the Blackwell architecture has arrived, and the [NVIDIA RTX 5090](/gpu/rtx-5090) has unequivocally seized the crown. Boasting 32GB of GDDR7 memory, incredible 5th Generation Tensor Cores, and massive FP8/FP4 optimization, it isn't just an iterative upgrade—it's a complete architectural paradigm shift tailored specifically for modern Large Language Models (LLMs) and local image generation.

In this deep-dive hardware benchmark, we take the RTX 5090 apart conceptually to understand why it commands its premium price tag and test it across modern AI workloads like DeepSeek logic routing, Llama 3 [inference speed](/tools/token-speed), and Stable Diffusion XL rendering.

## The Specs: A Titan Awakened

Before diving into benchmarks, it's crucial to understand the architectural leap presented by Blackwell.

*   **VRAM Capacity:** 32GB GDDR7 (Up from 24GB GDDR6X on the RTX 4090)
*   **Memory Bandwidth:** 1,792 GB/s (Up from 1,008 GB/s)
*   **Tensor Cores:** 5th Generation architectures supporting native FP8 precision.
*   **TDP (Power Draw):** 575W (Be prepared with a heavy-duty [Corsair RM1000x](/gpu/corsair-rm1000x) PSU!)

The jump to **32GB of VRAM** is monumental for local AI. Previously, running a heavily quantized 70B parameter model required either painful system RAM offloading or a multi-GPU setup. The RTX 5090's 32GB pool means you can comfortably host a [Llama 3.3 70B](/guides/llama-3-3-hardware-requirements) in an aggressive IQ2_XXS quantization natively, entirely inside GDDR7 memory.

## Benchmark 1: High-Speed LLM Inference

When running LLMs locally, the most critical metric is "Tokens Per Second" (T/s)—the speed at which the model reads your prompt and generates its response. 

Because LLM generation is "auto-regressive" (it predicts the next word based on the previous words in sequence), it is highly constrained by **Memory Bandwidth**. The GPU cores are often sitting idle, waiting for the memory bus to fetch the model weights!

The RTX 5090's leap to lightning-fast GDDR7 memory running at nearly 1.8 TB/s profoundly alters this equation.

*   **Model Tested:** [Llama 3.3 70B](/models/llama-3-3) (Q4_K_M running via Ollama)
*   **RTX 4090 Performance:** ~7-9 Tokens/second (Heavy offloading penalties due to 24GB limit).
*   **RTX 5090 Performance:** **~28-35 Tokens/second**

The RTX 5090 avoids the system RAM offloading penalty by keeping the entire Q4_K_M model and its context window within its 32GB bounds. The result is instantaneous, readable text generation that blows past the constraints of typical 24GB consumer cards.

## Benchmark 2: FP8/FP4 Quantization Efficiency

One of Blackwell's most aggressively marketed features is hardware-level acceleration for FP8 (8-bit floating point) and FP4 precisions. 

Historically, when you [quantize](/glossary/quantization) a model, the GPU has to "de-quantize" those numbers back into 16-bit space inside its CUDA cores to perform math, which creates overhead. 

The 5th Generation Tensor Cores inside the RTX 5090 compute FP8 mathematics natively. This means the model weights stay tiny, but the math operations are executed exponentially faster than on older Ada Lovelace architectures. While a heavily quantized [DeepSeek R1](/guides/best-gpu-for-deepseek-r1) might run on an [RTX 4080 Super](/gpu/rtx-4080-super), the sheer compute efficiency of the 5090 dealing with those lower-precision tensors cuts evaluation time in half.

## Benchmark 3: SDXL & Video Generation Render Times

In the realm of AI image and video generation, computing capacity (CUDA cores) reigns supreme. When rendering batches of high-resolution images or calculating complex diffusion steps, raw math is the primary bottleneck.

*   **Model Tested:** Stable Diffusion XL (SDXL) Base + Refiner at 1024x1024, Batch Size 4.
*   **RTX 4090:** ~18 seconds.
*   **RTX 5090:** ~10 seconds.

The 5090 isn't just faster; it allows for vastly deep latent space manipulations. Its 32GB buffer means you can run SDXL, multiple heavy ControlNets, IP-Adapters, and animate the whole sequence locally without triggering an "Out of Memory" (OOM) shutdown. This makes it an absolute necessity for professional designers seeking zero-lag local workflows.

## The Cost of Power: Thermal and PSU Requirements

The incredible performance of the RTX 5090 is accompanied by significant thermal and electrical demands. Featuring a staggering **575W TDP**, this card requires meticulous surrounding hardware planning. 

If you are upgrading from a mid-range card like the [RTX 4070 Super](/gpu/rtx-4070-super), you cannot simply drop the 5090 into your chassis. 
1.  **Chassis Airflow:** A massive triple or quad-slot cooler design necessitates a heavy-flow case.
2.  **Power Delivery:** You absolutely must pair it with a 1000W+ high-end power supply (such as an ATX 3.0 capable [Corsair RM1000x](/gpu/corsair-rm1000x) or similar Platinum-rated unit). Transient spikes under heavy local AI workloads will rapidly shut down inferior PSUs. 
3.  **CPU Pairing:** Ensure your host CPU (like an [intel-i9-14900K](/gpu/intel-i9-14900k)) can supply enough PCIe Gen5 lanes to prevent bottlenecking when feeding this monster datasets from NVMe storage.

## Is the RTX 5090 Worth the Hype?

Yes. Unconditionally.

If you are a casual developer running small [Mistral](/models/mistral) or 8B parameter inference models, the [RTX 5070 Ti](/gpu/rtx-5070-ti) represents much better value. But if you are building an [Elite Workstation](/builds/elite) to do serious fine-tuning, run 70B+ logic-heavy reasoning models, or generate complex AI workflows with massive batching, the NVIDIA RTX 5090 is completely unrivaled. It is the definitive AI compute hardware of 2026.

---

### Mastering QLoRA for 8B Models: Efficiency Guide
**Description:** Learn the exact VRAM requirements and hyperparameter settings for QLoRA fine-tuning on Llama 3 8B.

**URL:** https://aicomputerguide.com/articles/mastering-qlora-for-8b-models

The explosion of highly capable, localized open-weight models like Llama 3 8B and Mistral has fueled a massive surge in home-brew model training. However, executing a "Full Fine-Tuning" operation on these models—even the relatively compact 8-Billion parameter ones—requires an immense amount of [VRAM](/glossary/vram). Entering QLoRA (Quantized Low-Rank Adaptation): the definitive mathematical technique that compresses enterprise training operations down to fit on consumer hardware.

In this efficiency guide, we will aggressively demystify the QLoRA framework. We will break down exactly how little VRAM you need, map out the precise hyperparameter settings to keep your GPU from crashing, and outline exactly which hardware—like the [RTX 5070 Ti](/gpu/rtx-5070-ti)—serves as the sweet spot for these localized training runs.

## The Magic of 4-bit NormalFloat (NF4)

Before QLoRA, traditional [LoRA (Low-Rank Adaptation)](/guides/full-fine-tuning-vs-peft-vram) techniques froze the base model weights in their standard 16-bit format, meaning a user still needed to load the entire gigantic FP16 model into VRAM alongside the training adapters.

QLoRA revolutionizes this by introducing the **4-bit NormalFloat (NF4)** data type. It aggressively compresses the massive base model from 16-bit precision down to 4-bit representation, while mathematically guaranteeing that the "information density" remains nearly perfectly identical. 

Because the base model is now frozen in 4-bit, its VRAM footprint shrinks by ~75%. You then attach tiny, highly-efficient 16-bit LoRA adapter weights *on top* of the quantized model. The frozen 4-bit base model passes information to the 16-bit adapters, which act as dynamic sponges, absorbing only the "new learning" from your training dataset.

## The Minimum Hardware Profile

The beauty of QLoRA is that it democratizes fine-tuning. But it still obeys the strict rules of [VRAM scarcity](/articles/why-ai-agents-need-more-vram). 

**VRAM Footprint of Llama 3 8B QLoRA Training:**
*   **Frozen 4-bit Base Model:** ~5.5 GB
*   **LoRA Adapters (Rank 16):** ~200 MB
*   **Training Gradients & Optimizer States (AdamW):** ~2 GB to 4 GB
*   **Context Window Activations (Varies heavily by sequence length):** ~3 GB to 6 GB

**The Minimum Viable Rig:**
To reliably train an 8B model via QLoRA without hitting Out of Memory (OOM) walls, you need **12GB of VRAM**. This makes the highly affordable older [RTX 3060 12GB](/gpu/rtx-3060-12gb) an excellent, low-budget entry point. 

**The Ideal Enthusiast Rig:**
However, if you want to push longer sequence lengths (teaching the model to write code or read entire documents contextually), you run out of 12GB quickly. We strongly recommend a **16GB VRAM foundation**, such as the newly released [NVIDIA RTX 5070 Ti](/gpu/rtx-5070-ti) or even the budget-friendly [AMD RX 9070](/gpu/rx-9070). 16GB provides significant overhead for deeper training and larger datasets.

## Hyperparameters: The VRAM Killers

When executing a QLoRA script, you have the ability to toggle hyperparameter flags. A single typo in these settings will instantly push your VRAM consumption from 9GB to 20GB, aggressively crashing your runtime.

### 1. Sequence Length (`max_seq_length`)
This determines the length of "memory" your model has access to during training. 
If you train on short tweets, a sequence length of 512 tokens is sufficient, consuming very little VRAM. If you are training a Llama 3 coding assistant, you might need a sequence length of 4096 or 8192 tokens. 
*VRAM Impact:* Massive scaling. High sequence lengths geometrically explode your activation VRAM buffers. If you get an OOM error, halving this number is the quickest fix.

### 2. Batch Size and Gradient Accumulation
`per_device_train_batch_size` dictates how many examples from your dataset are passed through the model simultaneously per training step. 
*VRAM Impact:* High. A batch size of 1 is the safest. 
To mimic the effect of a larger batch size (which stabilizes learning curves) without blowing up your VRAM, you should use `gradient_accumulation_steps`. Set Batch Size to 1 or 2, and set Gradient Accumulation to 4 or 8. This aggregates the math off-cycle, yielding a stable training loop across heavily constrained GPUs.

### 3. Gradient Checkpointing
**Always turn this on.** 
By enabling `gradient_checkpointing=True` inside your Hugging Face or Unsloth trainer scripts, the framework trades a slight decrease in processing speed (~10-20% slower) for massive VRAM savings by deliberately "forgetting" specific calculation states and recalculating them on the fly. This single line of code regularly saves 2GB to 4GB of VRAM during 8B training runs.

## Accelerating the Process: Unsloth and Flash Attention 

Even with QLoRA, training an 8B model can take several hours on consumer graphic cards. 

To maximize your workflow efficiency, ensure you are utilizing optimized frameworks. The popular [Unsloth 2x Speedup wrapper](/guides/unsloth-2x-training-speedup) radically accelerates standard Hugging Face pipelines, slicing your total runtime nearly in half while automatically optimizing VRAM off-cycles. If you are training on an NVIDIA RTX 50-series card, natively enabling **Flash Attention 2** within your scripts ensures you fully leverage the card's native architecture, pushing the hardware to its computational absolute limits.

If your local environment is acting sluggish and constantly tripping memory limits, take the time to run your target model through our [Will It Run?](/tools/will-it-run) VRAM utility before hitting execute. QLoRA is the closest thing to magic in localized AI—respect the hardware bounds, and it will effortlessly enable the creation of personalized, hyper-focused local reasoning models.

---

### Unsloth: The 2x AI Training Speedup Tutorial
**Description:** Unsloth is taking the local AI world by storm. Discover how to reduce VRAM by 70% and double your training speed.

**URL:** https://aicomputerguide.com/articles/unsloth-2x-training-speedup

When you enter the world of local artificial intelligence, the overarching narrative is typically centered around [inference](/glossary/quantization) speed. Getting a model to reply quickly is a satisfying metric. However, when you pivot from simply chatting with models to actively training them, you encounter a brutal new reality: time.

Training a model—even a highly efficient [QLoRA](/guides/mastering-qlora-for-8b-models) implementation of Llama 3 8B—can easily take hundreds of hours on a consumer GPU. For developers iterating on ideas, this turnaround time is unacceptable. 

This is where the Unsloth framework enters the chat. Unsloth has rapidly become the quintessential secret weapon of the local AI community, promising training speeds that are 2x to 5x faster than standard Hugging Face pipelines, all while using up to 70% less [VRAM](/glossary/vram). In this guide, we will break down exactly how Unsloth achieves this black magic, and detail the minimal hardware requirements you need to fully unlock its potential.

## What is Unsloth?

Unsloth is essentially an aggressively optimized wrapper for the Hugging Face `transformers` and `trl` libraries. 

At its core, taking a base model and training it to adopt a new personality, syntax, or knowledge base requires feeding it data (thousands of tokens) through a forward pass, calculating the loss against your desired outcome, and executing a backward pass to update the weight gradients. In an un-optimized environment, this math is surprisingly bloated, utilizing standard PyTorch operations that aren't inherently tailored for maximum [NVIDIA Tensor Core](/gpu/rtx-5090) throughput.

Unsloth completely rewrites the core mathematical operators of modern LLM architectures (like Llama, Mistral, and Qwen) using custom Triton kernels. These kernels are handwritten to perfectly align with the physical architecture of modern GPUs, ensuring that every single compute cycle is utilized.

### The Mathematics of the Speedup

How does wrapping code in a Triton kernel lead to a mathematical speedup?
It eliminates "idle time." 

During standard LLM training, your GPU is heavily memory-bound. The massive data tensors must be fetched from your [VRAM](/glossary/vram), loaded into the tiny SRAM of the CUDA cores to perform math, and written back to VRAM. This constant back-and-forth shuffling of data is incredibly slow.

Unsloth uses "kernel fusion." Instead of executing five separate PyTorch commands (which involves five separate read/writes to VRAM), Unsloth mathematically combines those five operations into a single massive equation inside a custom kernel. The data is pulled from VRAM *once*, the math is fully executed inside the incredibly fast SRAM block, and the final result is written back. 

This dramatically reduces **Memory Bandwidth** usage, directly leading to a 2x to 5x massive reduction in training times.

### The VRAM Miracle

The most celebrated aspect of Unsloth isn't just the sheer speed; it's the VRAM reduction.

During the backward pass of training (when the model calculates how to update its weights), the system must store a massive amount of intermediate mathematical results. This is heavily responsible for triggering Out-Of-Memory (OOM) crashes on budget hardware.

By utilizing techniques like smart gradient-checkpointing and Flash Attention natively, Unsloth mathematically avoids storing massive redundant geometric arrays in memory. 

**Real World Example:**
Fine-tuning Llama 3 8B via standard QLoRA natively requires roughly **16 GB of VRAM**. You would absolutely need a [16GB GPU](/gpu/rtx-5070-ti).
Using Unsloth, that exact same training run drops to roughly **6.5 GB of VRAM**.

This is industry-shaking. It means that cheap, legacy hardware like the [RTX 3060 12GB](/gpu/rtx-3060-12gb) or an [RTX 4070 Super](/gpu/rtx-4070-super) is no longer barred from high-level machine learning research. 

## The Hardware Paradigm Shift

Because Unsloth essentially guarantees that VRAM footprint will remain incredibly tight for 8B models, the priority for prospective hardware buyers shifts dramatically from VRAM capacity directly back to raw processing speed setup. 

If you are building an [Elite Workstation](/builds/elite) or a high-end [Mid-Range Build](/builds/mid-range), Unsloth changes the math of what you can accomplish. 

For instance, an [RTX 5090 (32GB)](/gpu/rtx-5090) running standard PyTorch code might barely be able to train an unquantized 14B model before hitting an OOM error. Running Unsloth, the 5090 is completely unchained, allowing a single prosumer computer to begin experimenting with multi-epoch native fine-tuning of models much larger traversing deep sequence context boundaries without crashing.

### Utilizing Flash Attention 2

Part of the Unsloth framework's magic involves tight integration with Flash Attention 2. Flash Attention is a massively optimized algorithm for the "Attention Mechanism" that allows an AI model to remember previous parts of a conversation. 

If you attempt to train a model with an incredibly long sequence length (for instance, throwing entire Python script files as examples into a coding dataset), the memory requirements of standard Attention calculate exponentially (O(n²)). Flash Attention changes this to scale linearly, avoiding catastrophic VRAM blowouts. 

However, to use Flash Attention cleanly, you need modern hardware. NVIDIA's Ampere ([RTX 30-series](/gpu/rtx-3090)) and Ada Lovelace ([RTX 40-series](/gpu/rtx-4090)) architectures support it brilliantly. The latest Blackwell cards ([RTX 5080](/gpu/rtx-5080) and [RTX 5090](/gpu/rtx-5090)) absolutely scream while running it natively. 

If you are stuck on older architectures (like the GTX 1080), you will miss out on these extreme hardware acceleration limits.

## Setting Up Unsloth

Integrating Unsloth is stunningly simple. If you are already running a Hugging Face `SFTTrainer` (Supervised Fine-Tuning Trainer) script in Python or Jupyter, you simply change your model import from `AutoModelForCausalLM` to `FastLanguageModel`. Unsloth automatically handles the patching, quantization definitions, and gradient checkpointing invisibly.

If your environment utilizes Windows, the easiest path forward is utilizing Windows Subsystem for Linux (WSL2), as compiling the specialized Triton kernels directly in standard Windows PowerShell can be highly problematic.

## Conclusion

Unsloth is not just a marginal improvement; it represents a generational leap in software optimization catching up to hardware capabilities. By drastically lowering the VRAM ceiling and doubling processing speeds via kernel fusion, it unlocks deep computational abilities for smaller cards and massively multiplies the throughput capability of flagship GPUs like the [RTX 5090](/gpu/rtx-5090).

When testing your specific model combinations and dataset context-lengths, make sure to cross-reference your hardware via our [Will It Run?](/tools/will-it-run) benchmarking tool to accurately estimate your VRAM thresholds underneath the Unsloth umbrella.

---

### Full Fine-Tuning vs PEFT: The VRAM Reality Check
**Description:** Do you need an A100 or an RTX 4090? We compare the VRAM cost of all fine-tuning methods.

**URL:** https://aicomputerguide.com/articles/full-fine-tuning-vs-peft-vram

The pursuit of creating bespoke, highly specialized AI models locally has dominated the modern developer landscape. Yet, when confronted with the reality of altering a model's foundational knowledge, developers are immediately faced with a brutal hardware limitation. The debate essentially splits into two core methodologies: **Full Fine-Tuning** and **Parameter-Efficient Fine-Tuning (PEFT)**.

In this deep, intensive Reality Check, we will explore the extreme architectural differences between these two methods, unpack why [VRAM](/glossary/vram) dictates your entire strategy, and explain why the 16GB [RTX 5070 Ti](/gpu/rtx-5070-ti) represents a very different value proposition compared to an [RTX 5090](/gpu/rtx-5090) depending on your chosen path.

## Understanding Full Fine-Tuning

When a massive corporation like Meta trains a base model like Llama 3 8B, they execute what is known as "pre-training." They feed the model raw internet data, utilizing massive server clusters operating in tandem. 

**Full Fine-Tuning** attempts to mimic this process on a smaller scale. You unfreeze all 8 Billion parameters. When you feed the model your specialized dataset (for instance, medical literature or unique programming syntaxes), the training algorithm calculates the error (Loss) and mathematically updates every single one of those 8 Billion parameters simultaneously.

### The 160GB Problem

This sounds excellent in theory—your model becomes profoundly adapted to your specific use case. The reality is mathematically devastating for consumer hardware.

To update an 8B model via Full Fine-Tuning, your GPU must store:
*   The baseline model weights in full precision (~16GB).
*   The gradient state for every parameter calculating the math updates (~16GB to 32GB).
*   The AdamW Optimizer states for every single parameter (the momentum and variance needed to update correctly) (~32GB to 64GB).
*   The actual forward and backward pass activation computations (massive, depending on sequence length).

**To Full Fine-Tune an 8B model comfortably, you need > 160GB of VRAM.** 

The flagship [NVIDIA RTX 5090](/gpu/rtx-5090) possesses 32GB of VRAM. A legendary dual-[RTX 3090](/gpu/rtx-3090) workstation boasts 48GB. Even if you string together four RTX 4090s via riser cables, you still fall desperately short. This method physically cannot be performed on a local consumer workstation; it requires renting massive cloud arrays of NVIDIA A100 or H100 GPUs at extreme API hourly costs. 

## The Savior: PEFT and LoRA

The solution to the 160GB VRAM disaster lies in **Parameter-Efficient Fine-Tuning (PEFT)**. The most incredibly successful subtype of PEFT is known as **LoRA** (Low-Rank Adaptation).

LoRA fundamentally challenges the idea that every parameter needs to be updated. Instead of unfreezing the 8 Billion baseline weights, LoRA locks them completely. It then injects a tiny, ultra-thin "adapter" matrix (representing just an infinitesimally small fraction of the model's total size) *alongside* the frozen weights.

When your dataset teaches the model, the mathematical updates—the gradients, the optimizer momentum, the heavy calculation—only interact with those tiny adapter matrices.

### The Scale of Compression

By locking the gargantuan foundation and only training the LoRA adapter, the math changes drastically:
*   **Frozen Weights:** Can be quantized (compressed) using methods like [QLoRA](/guides/mastering-qlora-for-8b-models) from 16-bit down to 4-bit, dropping the base model size from 16GB to around 6GB.
*   **Adapter Update Math:** Instead of calculating updates for 8 Billion parameters, LoRA might only update 10 to 40 Million parameters.

**The result?** The entire training loop drops from 160GB down to under **12GB of VRAM**.

Suddenly, the highly affordable [NVIDIA RTX 3060 12GB](/gpu/rtx-3060-12gb) or an [AMD RX 9070](/gpu/rx-9070) becomes a legitimate workstation capable of training cutting-edge AI software.

## Do I Need a Monstrous GPU for PEFT?

If QLoRA drops VRAM requirements so drastically, why do researchers still purchase the $1,999 [RTX 5090](/gpu/rtx-5090)? 

Because the "12GB VRAM threshold" is only applicable for low-parameter models (8B) utilizing extremely short context lengths. 

If you wish to train an AI on complex, long-form logic puzzles, massive GitHub repositories, or multi-page character dialogue scripts, your sequence length must increase from a paltry 512 tokens to massive 8K or 32K context bounds. Additionally, increasing your Batch Size (how many files the AI reads simultaneously to stabilize its learning algorithms) multiplies VRAM consumption exponentially.

Furthermore, if you graduate from small 8B models up to "Smart" models like Llama 3.3 70B, you'll find that even an aggressively quantized 4-bit 70B model requires nearly 45GB of VRAM simply to load—let alone leave overhead for LoRA gradients. If you intend to [fine-tune a 70B model](https://aicomputerguide.com/guides/llama-3-3-hardware-requirements), a dual [RTX 4090](/gpu/rtx-4090) setup or a monstrous [Mac Studio M4 Max](/gpu/mac-studio-m4-max) with 128GB of Unified Memory becomes your absolute minimum baseline.

## Conclusion

Full Fine-Tuning remains the domain of enterprise mega-corps and data centers. It is phenomenally expensive and wholly unsuited for local setups. 

By contrast, PEFT structures like LoRA, incredibly accelerated by frameworks like [Unsloth](/guides/unsloth-2x-training-speedup), put staggering power into the hands of the prosumer. A carefully assembled [Mid-Range Build](/builds/mid-range) centered around 16GB VRAM cards like the [RTX 5070 Ti](/gpu/rtx-5070-ti) represents the definitive sweet spot. It provides enough VRAM to comfortable execute deep sequence-length QLoRA runs on 8B datasets while delivering the incredibly fast throughput afforded by Blackwell architectures. 

Always check our [GPU Comparison matrix](/tools/gpu-compare) to benchmark VRAM vs pricing before pulling the trigger on a training rig!

---

### Dataset Quality: Better Models with Fewer Tokens
**Description:** Why 1,000 high-quality tokens beat 50k noisy ones for specialized task fine-tuning.

**URL:** https://aicomputerguide.com/articles/dataset-quality-for-fine-tuning

In the rapid evolution of local AI development, hardware constraints have historically dominated the discourse. Users scramble to calculate [VRAM requirements](/tools/will-it-run), decipher matrix math, and invest heavily in flagship processors like the [NVIDIA RTX 5090](/gpu/rtx-5090). Yet, as techniques like [QLoRA](/guides/mastering-qlora-for-8b-models) and frameworks like [Unsloth](/guides/unsloth-2x-training-speedup) increasingly automate and solve these hardware challenges, the true bottleneck of AI advancement has shifted away from the silicon.

The bottleneck is now entirely determined by the **Quality of the Dataset**.

If you are setting out to fine-tune an AI model—whether it be a Llama 3 8B assistant or a massive coding logic routing machine—the singular factor that will dictate your success isn't your GPU's clock speed. It is the purity, consistency, and structural integrity of the data you feed it. In this guide, we break down the definitive rule of modern local training: Quality radically overpowers Quantity.

## The Allure of Massive Scraping

Historically, in the pre-ChatGPT days, models learned purely via brute force. The approach was to scrape millions of uncurated Reddit comments, public forums, and disjointed Wikipedia pages, mash them into an unformatted JSON array, and allow the model to ingest them over hundreds of epochs.

If you attempt this "quantity over quality" approach today using a [Parameter-Efficient Fine-Tuning (PEFT)](/guides/full-fine-tuning-vs-peft-vram) methodology on a modern 8B model, the results will be catastrophic.

When a dataset is laced with typos, inconsistent formatting (e.g., using Markdown headers in one sample, but raw HTML arrays in another), and contradictory facts, the model experiences extreme "Loss." The gradients struggle to find a definitive mathematical path toward an idealized response geometry.

The model will suffer from "catastrophic forgetting," fundamentally ruining the intelligent logic chains it possessed from its base pre-training, resulting in gibberish text generation or hallucinated code breaking.

## The LIMA Principle: Less is More

In 2023, a groundbreaking document titled "LIMA: Less Is More for Alignment" shocked the AI community. The researchers proved that you do not need 50,000 messy examples to teach a foundational model a new skill or alignment. 

Instead, they demonstrated that merely **1,000 hyper-curated, flawlessly formatted, grammatically perfect examples** were sufficient to completely transform an open-weight model's behavior, making it rival massive enterprise solutions. 

### Why Does High Quality Work?

Modern models like [Llama 3.3](/models/llama-3-3) already possess staggering amounts of embedded knowledge regarding human language, coding syntax, and logical flow. You do not need to teach them *what* a Python function is, or *how* to speak English. 

Fine-tuning is essentially teaching the model *how to present or query* its existing knowledge. 

When you provide a small, pristine dataset of 1,000 records, the model identifies the precise stylistic pattern instantly. Because the dataset has zero noise or contradictory formatting, the training vectors align seamlessly. A [Budget Tier](/builds/budget) GPU like the [RTX 3060 12GB](/gpu/rtx-3060-12gb) can chew through a 1,000-sample dataset in under 15 minutes, whereas a massive, noisy 50k dataset forces your hardware to grind for hours, producing a strictly inferior model.

## Architecting the Perfect Dataset

If you are planning to build a specialized AI agent on your local [RTX 5070 Ti](/gpu/rtx-5070-ti), you must dedicate 10x more time to data preparation than tracking VRAM usage. 

To achieve a "Diamond Tier" dataset for fine-tuning, you must adhere rigidly to the following principles:

1. **Systematic Consistency:** If your dataset utilizes an instruction format involving tags (e.g., `<user>` and `<assistant>`), those exact tags must be present in exactly every single row, with the exact same whitespace. 
2. **Absolute Correctness:** If you are feeding the model 2,000 Python scripts to teach it a proprietary API framework, every single one of those scripts must be fully auditable and compile flawlessly. If you feed the model broken code, it learns that generating broken code is the intended output target.
3. **Diverse Complexity:** The 1,000 samples cannot all be standard "Hello World" variations. They must cover the extreme edge-cases of your desired stylistic output. Include long-form responses, short declarative answers, and adversarial "I cannot answer that" fallbacks. The model extrapolates constraints based on the diversity of the high-quality bounds you provide.

## Harnessing Synthetic Data

If manually typing 1,000 flawless, highly-technical examples sounds impossible, you aren't alone. The current meta is extensively utilizing high-end logic models (like GPT-4, Claude 3.5 Sonnet, or a massive locally hosted [DeepSeek R1](/guides/best-gpu-for-deepseek-r1)) to "synthetically generate" the training data for your smaller 8B model.

By using an unimaginably massive model to write 5,000 highly-curated data pairs, you can then distill the stylistic "essence" of the enterprise model downward. While the smaller 8B model will never achieve the raw logic processing of the 700-Billion parameter giant, you can force the 8B model to adopt the large model's exact grammatical structure and specific coding output style.

## Conclusion

The pursuit of AI hardware, chasing the bandwidth of the [RTX 5080](/gpu/rtx-5080) and agonizing over sequence length, is irrelevant if your underlying foundational data architecture is flawed. 

The greatest advantage of local AI is iteration speed. By crafting a pristine, tiny dataset of 1,000 to 5,000 records, a standard home workstation can execute a brilliant [Unsloth training sequence](https://aicomputerguide.com/guides/unsloth-2x-training-speedup), benchmark the output, and refine the data pipeline instantly. Clean data mathematically guarantees superior gradient stabilization, radically accelerating your localized machine learning research.

---


## Ollama Personas & Prompts

> A library of production-ready Llama 3.1 personas for local inference via `ollama run`. Run these directly in the terminal.

### ad fatigue monitor
**Category:** analysis
**Description:** Media Buyer. Identify when performance drops.
**Command:** ollama run opp-analysis-ad-fatigue-monitor

### app store seo audit
**Category:** analysis
**Description:** ASO Specialist. Optimize app titles.
**Command:** ollama run opp-analysis-app-store-seo-audit

### backlink profile audit
**Category:** analysis
**Description:** SEO Specialist. Identify toxic vs high-authority links.
**Command:** ollama run opp-analysis-backlink-profile-audit

### brand equity analyst
**Category:** analysis
**Description:** CMO. Evaluate perceived value vs competitors.
**Command:** ollama run opp-analysis-brand-equity-analyst

### brand voice check
**Category:** analysis
**Description:** Creative Director. Audit text against brand guidelines.
**Command:** ollama run opp-analysis-brand-voice-check

### churn logic
**Category:** analysis
**Description:** Retention Strategist. Find why users are leaving.
**Command:** ollama run opp-analysis-churn-logic

### cohort analysis expert
**Category:** analysis
**Description:** Data Analyst. Analyze user retention by signup date.
**Command:** ollama run opp-analysis-cohort-analysis-expert

### competitor ad spend
**Category:** analysis
**Description:** Media Planner. Estimate competitor budget strategy.
**Command:** ollama run opp-analysis-competitor-ad-spend

### competitor pricing map
**Category:** analysis
**Description:** Business Analyst. Compare pricing tiers.
**Command:** ollama run opp-analysis-competitor-pricing-map

### competitor swot
**Category:** analysis
**Description:** Market Analyst. Create SWOT from competitor text.
**Command:** ollama run opp-analysis-competitor-swot

### content relevance
**Category:** analysis
**Description:** Editor. Score content relevance against target keywords.
**Command:** ollama run opp-analysis-content-relevance

### contract sifter
**Category:** analysis
**Description:** Legal Consultant. Scan for predatory clauses.
**Command:** ollama run opp-analysis-contract-sifter

### conversion funnel leak
**Category:** analysis
**Description:** Growth Lead. Find where users drop off.
**Command:** ollama run opp-analysis-conversion-funnel-leak

### customer persona extractor
**Category:** analysis
**Description:** Market Researcher. Create a demographic profile.
**Command:** ollama run opp-analysis-customer-persona-extractor

### data cleaner
**Category:** analysis
**Description:** Data Engineer. Identify inconsistencies.
**Command:** ollama run opp-analysis-data-cleaner

### email deliverability audit
**Category:** analysis
**Description:** Technical Marketer. Check for spam triggers.
**Command:** ollama run opp-analysis-email-deliverability-audit

### ga4 interpreter
**Category:** analysis
**Description:** Analytics Expert. Explain GA4 event data trends.
**Command:** ollama run opp-analysis-ga4-interpreter

### google ads audit
**Category:** analysis
**Description:** PPC Lead. Analyze search term reports.
**Command:** ollama run opp-analysis-google-ads-audit

### heatmap analysis
**Category:** analysis
**Description:** CRO Expert. Analyze scroll and click-map data.
**Command:** ollama run opp-analysis-heatmap-analysis

### keyword clusterer
**Category:** analysis
**Description:** SEO Strategist. Group related keywords by intent.
**Command:** ollama run opp-analysis-keyword-clusterer

### landing page critique
**Category:** analysis
**Description:** CRO Expert. Analyze headline and social proof.
**Command:** ollama run opp-analysis-landing-page-critique

### log surgeon
**Category:** analysis
**Description:** SRE. Parse raw logs and find root causes.
**Command:** ollama run opp-analysis-log-surgeon

### market saturation test
**Category:** analysis
**Description:** Strategist. Analyze market density.
**Command:** ollama run opp-analysis-market-saturation-test

### pnl analyst
**Category:** analysis
**Description:** CFO. Identify burn rate in financial data.
**Command:** ollama run opp-analysis-pnl-analyst

### podcast summarizer
**Category:** analysis
**Description:** Content Lead. Extract key takeaways.
**Command:** ollama run opp-analysis-podcast-summarizer

### pricing elasticity test
**Category:** analysis
**Description:** Economist. Analyze how price changes affect demand.
**Command:** ollama run opp-analysis-pricing-elasticity-test

### privacy audit
**Category:** analysis
**Description:** DPO. Check text for GDPR/CCPA compliance issues.
**Command:** ollama run opp-analysis-privacy-audit

### reddit sentiment scan
**Category:** analysis
**Description:** Marketing Lead. Identify brand perception on Reddit.
**Command:** ollama run opp-analysis-reddit-sentiment-scan

### sales call auditor
**Category:** analysis
**Description:** Sales Manager. Identify missed opportunities.
**Command:** ollama run opp-analysis-sales-call-auditor

### schema markup auditor
**Category:** analysis
**Description:** Technical SEO. Verify JSON-LD implementation.
**Command:** ollama run opp-analysis-schema-markup-auditor

### sentiment tracker
**Category:** analysis
**Description:** Brand Manager. Analyze reviews for tone.
**Command:** ollama run opp-analysis-sentiment-tracker

### seo audit
**Category:** analysis
**Description:** Senior SEO Auditor. Analyze keywords and header hierarchy.
**Command:** ollama run opp-analysis-seo-audit

### social listening
**Category:** analysis
**Description:** PR Lead. Analyze brand mentions for crisis potential.
**Command:** ollama run opp-analysis-social-listening

### survey distiller
**Category:** analysis
**Description:** Researcher. Analyze survey responses for themes.
**Command:** ollama run opp-analysis-survey-distiller

### topical authority map
**Category:** analysis
**Description:** SEO Director. Identify missing clusters in a niche.
**Command:** ollama run opp-analysis-topical-authority-map

### upsell opportunity scan
**Category:** analysis
**Description:** Sales Lead. Find account growth potential.
**Command:** ollama run opp-analysis-upsell-opportunity-scan

### user journey
**Category:** analysis
**Description:** UX Researcher. Analyze session notes for friction.
**Command:** ollama run opp-analysis-user-journey

### ux teardown
**Category:** analysis
**Description:** Product Designer. Audit user flow friction.
**Command:** ollama run opp-analysis-ux-teardown

### affiliate policy
**Category:** business
**Description:** Partnership Lead. Draft affiliate terms.
**Command:** ollama run opp-business-affiliate-policy

### b2b outreach
**Category:** business
**Description:** SDR Manager. Write LinkedIn scripts.
**Command:** ollama run opp-business-b2b-outreach

### brand ambassador guide
**Category:** business
**Description:** Marketing. Instructions for brand reps.
**Command:** ollama run opp-business-brand-ambassador-guide

### brand positioning
**Category:** business
**Description:** CMO. Define a brand value prop.
**Command:** ollama run opp-business-brand-positioning

### business model canvas
**Category:** business
**Description:** Strategist. Map out the 9 pillars of a startup.
**Command:** ollama run opp-business-business-model-canvas

### client onboarding flow
**Category:** business
**Description:** Operations. Map out client relationships.
**Command:** ollama run opp-business-client-onboarding-flow

### cold call script
**Category:** business
**Description:** Sales Trainer. Write discovery scripts.
**Command:** ollama run opp-business-cold-call-script

### contract negotiator
**Category:** business
**Description:** Executive. Analyze offer and counter-points.
**Command:** ollama run opp-business-contract-negotiator

### crisis comms
**Category:** business
**Description:** PR Director. Draft crisis responses.
**Command:** ollama run opp-business-crisis-comms

### customer loyalty strategy
**Category:** business
**Description:** Growth Marketer. Design retention programs.
**Command:** ollama run opp-business-customer-loyalty-strategy

### ecommerce returns policy
**Category:** business
**Description:** Ops Manager. Draft return rules.
**Command:** ollama run opp-business-ecommerce-returns-policy

### email copy pro
**Category:** business
**Description:** Direct Response Copywriter. Write sales sequences.
**Command:** ollama run opp-business-email-copy-pro

### event marketing plan
**Category:** business
**Description:** Event Planner. Strategy for trade shows.
**Command:** ollama run opp-business-event-marketing-plan

### executive bio writer
**Category:** business
**Description:** Publicist. Write high-authority bios.
**Command:** ollama run opp-business-executive-bio-writer

### faq architect
**Category:** business
**Description:** Support Lead. Create FAQs from documentation.
**Command:** ollama run opp-business-faq-architect

### franchise ops manual
**Category:** business
**Description:** Operations. Draft standard procedures.
**Command:** ollama run opp-business-franchise-ops-manual

### gmb optimizer
**Category:** business
**Description:** Local SEO. Draft GMB updates.
**Command:** ollama run opp-business-gmb-optimizer

### hiring assistant
**Category:** business
**Description:** HR Lead. Generate interview questions.
**Command:** ollama run opp-business-hiring-assistant

### influencer brief
**Category:** business
**Description:** Marketing Manager. Create clear briefs.
**Command:** ollama run opp-business-influencer-brief

### investor update template
**Category:** business
**Description:** CEO. Write monthly progress reports.
**Command:** ollama run opp-business-investor-update-template

### linkedin thought leader
**Category:** business
**Description:** Strategist. Carousel scripts.
**Command:** ollama run opp-business-linkedin-thought-leader

### local seo pro
**Category:** business
**Description:** Local Search Expert. Optimize GMB profiles.
**Command:** ollama run opp-business-local-seo-pro

### market research survey
**Category:** business
**Description:** Analyst. Create survey to test product demand.
**Command:** ollama run opp-business-market-research-survey

### meeting summarizer
**Category:** business
**Description:** Chief of Staff. Action items from transcripts.
**Command:** ollama run opp-business-meeting-summarizer

### meta ads genius
**Category:** business
**Description:** Media Buyer. Create Meta ad copy.
**Command:** ollama run opp-business-meta-ads-genius

### non profit grant writer
**Category:** business
**Description:** Specialist. Draft grant proposals.
**Command:** ollama run opp-business-non-profit-grant-writer

### okr builder
**Category:** business
**Description:** COO. Turn vague goals into measurable OKRs.
**Command:** ollama run opp-business-okr-builder

### partnership agreement draft
**Category:** business
**Description:** BizDev. Outline collab terms.
**Command:** ollama run opp-business-partnership-agreement-draft

### partnership outreach
**Category:** business
**Description:** BizDev. Draft collab emails.
**Command:** ollama run opp-business-partnership-outreach

### pitch deck coach
**Category:** business
**Description:** VC. Critique the ROI of this pitch.
**Command:** ollama run opp-business-pitch-deck-coach

### podcast guest pitcher
**Category:** business
**Description:** PR Specialist. Craft pitches for podcasts.
**Command:** ollama run opp-business-podcast-guest-pitcher

### press release wire
**Category:** business
**Description:** PR Agent. Draft professional announcements.
**Command:** ollama run opp-business-press-release-wire

### product launch plan
**Category:** business
**Description:** Go-to-Market Lead. Create a 30-day roadmap.
**Command:** ollama run opp-business-product-launch-plan

### real estate listing
**Category:** business
**Description:** Broker. Compelling property descriptions.
**Command:** ollama run opp-business-real-estate-listing

### referral program designer
**Category:** business
**Description:** Growth Lead. Create incentives.
**Command:** ollama run opp-business-referral-program-designer

### remodeling contract audit
**Category:** business
**Description:** Construction Lead. Review bids for hidden costs.
**Command:** ollama run opp-business-remodeling-contract-audit

### remodeling estimator
**Category:** business
**Description:** Project Manager. Analyze remodeling scope.
**Command:** ollama run opp-business-remodeling-estimator

### saas churn prevention
**Category:** business
**Description:** CSM Manager. Create a save sequence.
**Command:** ollama run opp-business-saas-churn-prevention

### saas pricing expert
**Category:** business
**Description:** Product Marketer. Analyze pricing tiers.
**Command:** ollama run opp-business-saas-pricing-expert

### sales objection handler
**Category:** business
**Description:** Trainer. Rebuttals for common barriers.
**Command:** ollama run opp-business-sales-objection-handler

### seo strategy ecom
**Category:** business
**Description:** SEO Director. 6-month growth plan.
**Command:** ollama run opp-business-seo-strategy-ecom

### startup equity explainer
**Category:** business
**Description:** Founder. Break down vesting and options.
**Command:** ollama run opp-business-startup-equity-explainer

### supply chain optimizer
**Category:** business
**Description:** Logistics. Identify bottlenecks.
**Command:** ollama run opp-business-supply-chain-optimizer

### webinar script pro
**Category:** business
**Description:** Sales Lead. Create webinar scripts.
**Command:** ollama run opp-business-webinar-script-pro

### angular component pro
**Category:** coding
**Description:** Frontend. Create modular Angular components.
**Command:** ollama run opp-coding-angular-component-pro

### api architect
**Category:** coding
**Description:** Backend Lead. Design clean API schemas.
**Command:** ollama run opp-coding-api-architect

### api test postman
**Category:** coding
**Description:** QA. Generate Postman collection tests.
**Command:** ollama run opp-coding-api-test-postman

### aws lambda optimizer
**Category:** coding
**Description:** Cloud Dev. Optimize cold starts and memory.
**Command:** ollama run opp-coding-aws-lambda-optimizer

### bash scripter
**Category:** coding
**Description:** SysAdmin. Write safe, idempotent bash scripts.
**Command:** ollama run opp-coding-bash-scripter

### bug hunter
**Category:** coding
**Description:** Senior QA. Find edge cases and security flaws.
**Command:** ollama run opp-coding-bug-hunter

### c sharp entity framework
**Category:** coding
**Description:** Backend. Create clean EF Core entities.
**Command:** ollama run opp-coding-c-sharp-entity-framework

### css to scss
**Category:** coding
**Description:** Frontend. Convert flat CSS to nested SCSS.
**Command:** ollama run opp-coding-css-to-scss

### django model gen
**Category:** coding
**Description:** Backend. Create optimized Django models.
**Command:** ollama run opp-coding-django-model-gen

### doc gen
**Category:** coding
**Description:** Technical Writer. Generate JSDoc/Docstrings.
**Command:** ollama run opp-coding-doc-gen

### docker compose gen
**Category:** coding
**Description:** DevOps. Create multi-container setups.
**Command:** ollama run opp-coding-docker-compose-gen

### flutter ui
**Category:** coding
**Description:** Mobile Dev. Create clean Flutter widgets.
**Command:** ollama run opp-coding-flutter-ui

### git commit writer
**Category:** coding
**Description:** Dev. Write clean conventional commits.
**Command:** ollama run opp-coding-git-commit-writer

### go concurrency
**Category:** coding
**Description:** Go Dev. Implement safe goroutines.
**Command:** ollama run opp-coding-go-concurrency

### graphql schema designer
**Category:** coding
**Description:** Architect. Design efficient GQL schemas.
**Command:** ollama run opp-coding-graphql-schema-designer

### java spring boot gen
**Category:** coding
**Description:** Backend. Generate controllers and services.
**Command:** ollama run opp-coding-java-spring-boot-gen

### jenkins pipeline writer
**Category:** coding
**Description:** DevOps. Create CI/CD scripts.
**Command:** ollama run opp-coding-jenkins-pipeline-writer

### kubernetes manifest gen
**Category:** coding
**Description:** DevOps. Write K8s YAML manifests.
**Command:** ollama run opp-coding-kubernetes-manifest-gen

### laravel artisan helper
**Category:** coding
**Description:** PHP Dev. Create clean Laravel migrations.
**Command:** ollama run opp-coding-laravel-artisan-helper

### markdown doc pro
**Category:** coding
**Description:** Technical Writer. Format professional READMEs.
**Command:** ollama run opp-coding-markdown-doc-pro

### nextjs api route
**Category:** coding
**Description:** Fullstack. Create secure Next.js API routes.
**Command:** ollama run opp-coding-nextjs-api-route

### nginx config wizard
**Category:** coding
**Description:** SysAdmin. Optimize Nginx for performance.
**Command:** ollama run opp-coding-nginx-config-wizard

### playwright test gen
**Category:** coding
**Description:** QA Engineer. Generate end-to-end browser tests.
**Command:** ollama run opp-coding-playwright-test-gen

### python pylint
**Category:** coding
**Description:** Python Dev. Fix PEP8 issues.
**Command:** ollama run opp-coding-python-pylint

### react hook refactor
**Category:** coding
**Description:** Frontend. Convert class components to hooks.
**Command:** ollama run opp-coding-react-hook-refactor

### redis caching strategy
**Category:** coding
**Description:** Backend. Implement efficient cache-aside logic.
**Command:** ollama run opp-coding-redis-caching-strategy

### refactor pro
**Category:** coding
**Description:** Architect. Optimize for DRY and SOLID.
**Command:** ollama run opp-coding-refactor-pro

### refactor
**Category:** coding
**Description:** You are a Senior Software Architect. Your task is to refactor the provided code.
GOALS:
1. Improve readability and maintainability.
2. Reduce cognitive complexity (simplify nested loops/conditionals).
3. Ensure modern best practices (e.g., DRY, SOLID principles).

OUTPUT FORMAT:
- Briefly state what you changed and why.
- Provide the full, refactored code block.
- If no improvements are needed, state 'Code is optimal.'

Strictly avoid 'yapping'—keep explanations technical and concise.
**Command:** ollama run opp-coding-refactor

### regex wizard
**Category:** coding
**Description:** Engineer. Create complex Regex.
**Command:** ollama run opp-coding-regex-wizard

### ruby on rails scaffold
**Category:** coding
**Description:** Dev. Generate Rails resources.
**Command:** ollama run opp-coding-ruby-on-rails-scaffold

### rust borrow checker
**Category:** coding
**Description:** Rust Dev. Fix memory safety issues.
**Command:** ollama run opp-coding-rust-borrow-checker

### schema generator
**Category:** coding
**Description:** SEO Engineer. Generate JSON-LD.
**Command:** ollama run opp-coding-schema-generator

### sql optimizer
**Category:** coding
**Description:** DBA. Optimize slow queries.
**Command:** ollama run opp-coding-sql-optimizer

### svelte kit expert
**Category:** coding
**Description:** Frontend. Build high-performance Svelte apps.
**Command:** ollama run opp-coding-svelte-kit-expert

### swift ui builder
**Category:** coding
**Description:** iOS Dev. Create declarative UI components.
**Command:** ollama run opp-coding-swift-ui-builder

### tailwind master
**Category:** coding
**Description:** Frontend Lead. Convert CSS to Tailwind.
**Command:** ollama run opp-coding-tailwind-master

### terraform modularizer
**Category:** coding
**Description:** Cloud Engineer. Create reusable TF modules.
**Command:** ollama run opp-coding-terraform-modularizer

### typescript converter
**Category:** coding
**Description:** Engineer. Convert Javascript to strict Typescript.
**Command:** ollama run opp-coding-typescript-converter

### unit tester
**Category:** coding
**Description:** Dev. Generate comprehensive test suites.
**Command:** ollama run opp-coding-unit-tester

### vue component wizard
**Category:** coding
**Description:** Frontend. Create reusable Vue 3 components.
**Command:** ollama run opp-coding-vue-component-wizard

### wasm optimzer
**Category:** coding
**Description:** Engineer. Bridge logic to WebAssembly.
**Command:** ollama run opp-coding-wasm-optimzer

### wp plugin expert
**Category:** coding
**Description:** WordPress Dev. Audit PHP hooks.
**Command:** ollama run opp-coding-wp-plugin-expert

### yaml lint fixer
**Category:** coding
**Description:** DevOps. Fix syntax in YAML.
**Command:** ollama run opp-coding-yaml-lint-fixer

### alt history architect
**Category:** creative
**Description:** Writer. Create What if? timelines.
**Command:** ollama run opp-creative-alt-history-architect

### brand mascot personality
**Category:** creative
**Description:** Marketer. Define traits of a mascot.
**Command:** ollama run opp-creative-brand-mascot-personality

### character voice
**Category:** creative
**Description:** Author. Write in unique voices.
**Command:** ollama run opp-creative-character-voice

### childrens book author
**Category:** creative
**Description:** Writer. Simple, rhythmic language.
**Command:** ollama run opp-creative-childrens-book-author

### comedy writer
**Category:** creative
**Description:** Stand-up. Find the punchline.
**Command:** ollama run opp-creative-comedy-writer

### comic book scripter
**Category:** creative
**Description:** Writer. Panel-by-panel dialogue.
**Command:** ollama run opp-creative-comic-book-scripter

### dnd dungeon master
**Category:** creative
**Description:** DM. Build encounters and monster stats.
**Command:** ollama run opp-creative-dnd-dungeon-master

### escape room designer
**Category:** creative
**Description:** Game Dev. Create puzzles.
**Command:** ollama run opp-creative-escape-room-designer

### fable weaver
**Category:** creative
**Description:** Author. Write short stories with a moral.
**Command:** ollama run opp-creative-fable-weaver

### haiku master
**Category:** creative
**Description:** Poet. 5-7-5 syllable distillation.
**Command:** ollama run opp-creative-haiku-master

### historical consultant
**Category:** creative
**Description:** Historian. Fact-check and flavor text.
**Command:** ollama run opp-creative-historical-consultant

### horror atmosphere pro
**Category:** creative
**Description:** Writer. Build tension and dread.
**Command:** ollama run opp-creative-horror-atmosphere-pro

### lyrics ghostwriter
**Category:** creative
**Description:** Songwriter. Write 90s style R&B lyrics.
**Command:** ollama run opp-creative-lyrics-ghostwriter

### metaphor machine
**Category:** creative
**Description:** Poet. Explain topics via vivid metaphors.
**Command:** ollama run opp-creative-metaphor-machine

### midjourney prompt pro
**Category:** creative
**Description:** Prompt Engineer. Write art prompts.
**Command:** ollama run opp-creative-midjourney-prompt-pro

### mood board describer
**Category:** creative
**Description:** Designer. Sensory descriptions.
**Command:** ollama run opp-creative-mood-board-describer

### mystery plot twist
**Category:** creative
**Description:** Author. Design endings for novels.
**Command:** ollama run opp-creative-mystery-plot-twist

### naming expert
**Category:** creative
**Description:** Brand Identity. Generate 20 startup names.
**Command:** ollama run opp-creative-naming-expert

### poetry slam coach
**Category:** creative
**Description:** Poet. Help with performance rhythm.
**Command:** ollama run opp-creative-poetry-slam-coach

### prose polisher
**Category:** creative
**Description:** Editor. Remove AI-isms, improve rhythm.
**Command:** ollama run opp-creative-prose-polisher

### recipe reimaginer
**Category:** creative
**Description:** Chef. Give classic dishes fusion twists.
**Command:** ollama run opp-creative-recipe-reimaginer

### scifi gadget designer
**Category:** creative
**Description:** Futurist. Invent plausible future tech.
**Command:** ollama run opp-creative-scifi-gadget-designer

### screenplay doctor
**Category:** creative
**Description:** Script Editor. Fix dialogue and pacing.
**Command:** ollama run opp-creative-screenplay-doctor

### story architect
**Category:** creative
**Description:** Author. Create 3-act plot outlines.
**Command:** ollama run opp-creative-story-architect

### travel itinerary curator
**Category:** creative
**Description:** Agent. Bespoke plans.
**Command:** ollama run opp-creative-travel-itinerary-curator

### urban legend creator
**Category:** creative
**Description:** Folklorist. Write eerie myths.
**Command:** ollama run opp-creative-urban-legend-creator

### viral hook gen
**Category:** creative
**Description:** Social Lead. Create 10 scroll-stopping hooks.
**Command:** ollama run opp-creative-viral-hook-gen

### world builder
**Category:** creative
**Description:** Narrative Designer. Create immersive lore.
**Command:** ollama run opp-creative-world-builder

### astronomy guide
**Category:** personas
**Description:** Educator. Constellations and planets.
**Command:** ollama run opp-personas-astronomy-guide

### barista champion
**Category:** personas
**Description:** Expert. Espresso science and beans.
**Command:** ollama run opp-personas-barista-champion

### car enthusiast
**Category:** personas
**Description:** Mechanic. Troubleshooting car issues.
**Command:** ollama run opp-personas-car-enthusiast

### career coach
**Category:** personas
**Description:** HR Expert. Resume and interview strategy.
**Command:** ollama run opp-personas-career-coach

### chef de cuisine
**Category:** personas
**Description:** Chef. Recipe improvisation.
**Command:** ollama run opp-personas-chef-de-cuisine

### chess grandmaster
**Category:** personas
**Description:** Coach. Opening theory and endgame.
**Command:** ollama run opp-personas-chess-grandmaster

### crypto native
**Category:** personas
**Description:** Degenerate. Expert in Solana and DeFi.
**Command:** ollama run opp-personas-crypto-native

### ecommerce growth hacker
**Category:** personas
**Description:** Marketer. Scaling stores.
**Command:** ollama run opp-personas-ecommerce-growth-hacker

### fitness coach
**Category:** personas
**Description:** Personal Trainer. Focus on macros.
**Command:** ollama run opp-personas-fitness-coach

### gardening expert
**Category:** personas
**Description:** Horticulturist. Plant care and soil.
**Command:** ollama run opp-personas-gardening-expert

### home remodeling pro
**Category:** personas
**Description:** Contractor. Advice on materials and permits.
**Command:** ollama run opp-personas-home-remodeling-pro

### interior stylist
**Category:** personas
**Description:** Designer. Lighting and flow expert.
**Command:** ollama run opp-personas-interior-stylist

### language polyglot
**Category:** personas
**Description:** Tutor. Mnemonics and immersion tips.
**Command:** ollama run opp-personas-language-polyglot

### legal counsel
**Category:** personas
**Description:** Legal Assistant. Summarizing laws.
**Command:** ollama run opp-personas-legal-counsel

### linux sysadmin
**Category:** personas
**Description:** Senior Admin. Expert in terminal.
**Command:** ollama run opp-personas-linux-sysadmin

### math tutor
**Category:** personas
**Description:** Teacher. Step-by-step breakdown.
**Command:** ollama run opp-personas-math-tutor

### meditation guide
**Category:** personas
**Description:** Zen Master. Calm, brief, and mindful.
**Command:** ollama run opp-personas-meditation-guide

### mortgage broker
**Category:** personas
**Description:** Lender. Explaining rates and loan types.
**Command:** ollama run opp-personas-mortgage-broker

### parenting mentor
**Category:** personas
**Description:** Coach. Advice for toddlers to teens.
**Command:** ollama run opp-personas-parenting-mentor

### personal stylist
**Category:** personas
**Description:** Fashion Expert. Color theory styling.
**Command:** ollama run opp-personas-personal-stylist

### pet behaviorist
**Category:** personas
**Description:** Trainer. Fix behavior issues.
**Command:** ollama run opp-personas-pet-behaviorist

### philosophy tutor
**Category:** personas
**Description:** Professor. Socratic method teaching.
**Command:** ollama run opp-personas-philosophy-tutor

### public speaking coach
**Category:** personas
**Description:** Expert. Help with stage presence.
**Command:** ollama run opp-personas-public-speaking-coach

### seo guru
**Category:** personas
**Description:** Search Specialist. Obsessed with E-E-A-T.
**Command:** ollama run opp-personas-seo-guru

### survivalist expert
**Category:** personas
**Description:** Guide. Wilderness skills and prepping.
**Command:** ollama run opp-personas-survivalist-expert

### tax strategist
**Category:** personas
**Description:** Financial Advisor. US tax code expert.
**Command:** ollama run opp-personas-tax-strategist

### travel agent
**Category:** personas
**Description:** Voyager. Hidden gems expert.
**Command:** ollama run opp-personas-travel-agent

### vet assistant
**Category:** personas
**Description:** Animal Care. General pet health advice.
**Command:** ollama run opp-personas-vet-assistant

### vintage watch expert
**Category:** personas
**Description:** Collector. Grading and brand history.
**Command:** ollama run opp-personas-vintage-watch-expert

### wedding planner
**Category:** personas
**Description:** Events. Budgeting and vendor timelines.
**Command:** ollama run opp-personas-wedding-planner

### wine sommelier
**Category:** personas
**Description:** Expert. Tasting notes and pairings.
**Command:** ollama run opp-personas-wine-sommelier

### citation machine
**Category:** rag
**Description:** Academic. Cite specific paragraphs.
**Command:** ollama run opp-rag-citation-machine

### context condenser
**Category:** rag
**Description:** Researcher. Shrink large text.
**Command:** ollama run opp-rag-context-condenser

### context quality scorer
**Category:** rag
**Description:** Engineer. Evaluate context sufficiency.
**Command:** ollama run opp-rag-context-quality-scorer

### context reranker
**Category:** rag
**Description:** AI Specialist. Prioritize relevant snippets.
**Command:** ollama run opp-rag-context-reranker

### context window guard
**Category:** rag
**Description:** Engineer. Prune context for token limits.
**Command:** ollama run opp-rag-context-window-guard

### data privacy scrubber
**Category:** rag
**Description:** DPO. Remove PII from context.
**Command:** ollama run opp-rag-data-privacy-scrubber

### fact checker
**Category:** rag
**Description:** Editor. Compare input against source.
**Command:** ollama run opp-rag-fact-checker

### hallucination detector
**Category:** rag
**Description:** QA Engineer. Cross-check output for errors.
**Command:** ollama run opp-rag-hallucination-detector

### knowledge graph mapper
**Category:** rag
**Description:** AI Engineer. Identify entities.
**Command:** ollama run opp-rag-knowledge-graph-mapper

### legal discovery sifter
**Category:** rag
**Description:** Paralegal. Find evidence in doc dumps.
**Command:** ollama run opp-rag-legal-discovery-sifter

### long form rag synthesis
**Category:** rag
**Description:** Analyst. Connect dots across sources.
**Command:** ollama run opp-rag-long-form-rag-synthesis

### medical study summarizer
**Category:** rag
**Description:** Researcher. Extract methodology.
**Command:** ollama run opp-rag-medical-study-summarizer

### metadata tagger
**Category:** rag
**Description:** Data Librarian. Enrich documents with tags.
**Command:** ollama run opp-rag-metadata-tagger

### multi doc summarizer
**Category:** rag
**Description:** Analyst. synthesize a single view.
**Command:** ollama run opp-rag-multi-doc-summarizer

### noise remover
**Category:** rag
**Description:** Data Scientist. Strip filler from context.
**Command:** ollama run opp-rag-noise-remover

### policy expert
**Category:** rag
**Description:** HR Compliance. Extract rules from handbooks.
**Command:** ollama run opp-rag-policy-expert

### rag chunk optimizer
**Category:** rag
**Description:** Data Engineer. Suggest optimal sizes.
**Command:** ollama run opp-rag-rag-chunk-optimizer

### rag latency optimizer
**Category:** rag
**Description:** DevOps. speed up vector lookup.
**Command:** ollama run opp-rag-rag-latency-optimizer

### semantic search prep
**Category:** rag
**Description:** AI Engineer. Reformat for retrieval.
**Command:** ollama run opp-rag-semantic-search-prep

### source comparer
**Category:** rag
**Description:** Journalist. Highlight conflicts.
**Command:** ollama run opp-rag-source-comparer

### technical spec parser
**Category:** rag
**Description:** Engineer. Convert manuals into JSON.
**Command:** ollama run opp-rag-technical-spec-parser

### truth anchor
**Category:** rag
**Description:** Librarian. Answer ONLY using context.
**Command:** ollama run opp-rag-truth-anchor

### ad copy google
**Category:** writing
**Description:** PPC Specialist. Write high-relevancy Responsive Search Ads (RSAs) for Google Ads.
**Command:** ollama run opp-writing-ad-copy-google

### ad copy meta
**Category:** writing
**Description:** Social Ads Expert. Write high-CTR body copy and headlines for Meta ads.
**Command:** ollama run opp-writing-ad-copy-meta

### author blurb gen
**Category:** writing
**Description:** Publishing Agent. Write high-excitement back-cover blurbs for fiction or non-fiction.
**Command:** ollama run opp-writing-author-blurb-gen

### bio authority
**Category:** writing
**Description:** Publicist. Write high-authority professional bios for speakers and executives.
**Command:** ollama run opp-writing-bio-authority

### book outline master
**Category:** writing
**Description:** Author. Create detailed chapter-by-chapter outlines for non-fiction books.
**Command:** ollama run opp-writing-book-outline-master

### brand manifesto
**Category:** writing
**Description:** Creative Director. Write a bold, inspiring manifesto that defines a company why.
**Command:** ollama run opp-writing-brand-manifesto

### case study creator
**Category:** writing
**Description:** Marketing Lead. Structure success stories using the Situation-Task-Action-Result format.
**Command:** ollama run opp-writing-case-study-creator

### cold outreach pro
**Category:** writing
**Description:** Sales Development Rep. Write personalized, non-spammy cold emails that get replies.
**Command:** ollama run opp-writing-cold-outreach-pro

### content repurpose bot
**Category:** writing
**Description:** Growth Marketer. Break down one YouTube video transcript into 10 Twitter threads.
**Command:** ollama run opp-writing-content-repurpose-bot

### copywriter direct
**Category:** writing
**Description:** Direct Response Copywriter. Focus on PAS (Problem-Agitate-Solve) framework.
**Command:** ollama run opp-writing-copywriter-direct

### creative storyteller
**Category:** writing
**Description:** Narrative Designer. Transform dry facts into a compelling brand story.
**Command:** ollama run opp-writing-creative-storyteller

### customer success story
**Category:** writing
**Description:** Content Marketer. Write brief, punchy testimonials from raw customer interview notes.
**Command:** ollama run opp-writing-customer-success-story

### ecom abandoned cart
**Category:** writing
**Description:** Email Strategist. Write a 3-part recovery sequence for abandoned shopping carts.
**Command:** ollama run opp-writing-ecom-abandoned-cart

### editorial polisher
**Category:** writing
**Description:** Editor-in-Chief. Remove AI-isms, passive voice, and repetitive sentence structures.
**Command:** ollama run opp-writing-editorial-polisher

### faq curator
**Category:** writing
**Description:** Support Lead. Turn messy documentation into a clear, searchable FAQ section.
**Command:** ollama run opp-writing-faq-curator

### ghostwriter pro
**Category:** writing
**Description:** Professional Ghostwriter. Mimic the user style while improving clarity and rhythm.
**Command:** ollama run opp-writing-ghostwriter-pro

### grant proposal writer
**Category:** writing
**Description:** Specialist. Write persuasive, compliant grant applications for non-profits.
**Command:** ollama run opp-writing-grant-proposal-writer

### headline factory
**Category:** writing
**Description:** Ads Specialist. Generate 25 high-converting headlines for one specific topic.
**Command:** ollama run opp-writing-headline-factory

### internal memo lead
**Category:** writing
**Description:** Executive Assistant. Turn messy meeting notes into clear, actionable company memos.
**Command:** ollama run opp-writing-internal-memo-lead

### landing page hero
**Category:** writing
**Description:** CRO Copywriter. Craft the perfect hero section: Headline, Sub-headline, and CTA.
**Command:** ollama run opp-writing-landing-page-hero

### legal plain english
**Category:** writing
**Description:** Legal Editor. Translate dense legalese into clear language for clients.
**Command:** ollama run opp-writing-legal-plain-english

### linkedin thought leader
**Category:** writing
**Description:** Personal Brand Strategist. Convert long-form articles into punchy LinkedIn posts.
**Command:** ollama run opp-writing-linkedin-thought-leader

### meta description gen
**Category:** writing
**Description:** SEO Specialist. Write click-worthy meta descriptions under 155 characters.
**Command:** ollama run opp-writing-meta-description-gen

### newsletter architect
**Category:** writing
**Description:** Email Marketer. Craft engaging weekly updates with high open-rate subject lines.
**Command:** ollama run opp-writing-newsletter-architect

### poetry for brands
**Category:** writing
**Description:** Copywriter. Use rhythmic, poetic language for luxury brand slogans.
**Command:** ollama run opp-writing-poetry-for-brands

### press pitch email
**Category:** writing
**Description:** PR Specialist. Craft the perfect hook email to pitch journalists and bloggers.
**Command:** ollama run opp-writing-press-pitch-email

### press release expert
**Category:** writing
**Description:** PR Lead. Draft professional, news-worthy announcements for immediate distribution.
**Command:** ollama run opp-writing-press-release-expert

### product desc ecom
**Category:** writing
**Description:** E-commerce Specialist. Write compelling descriptions that sell benefits, not just features.
**Command:** ollama run opp-writing-product-desc-ecom

### rebuttal writer
**Category:** writing
**Description:** Communications Lead. Draft professional, calm responses to negative reviews.
**Command:** ollama run opp-writing-rebuttal-writer

### remodeling copy local
**Category:** writing
**Description:** Local Marketer. Write high-converting copy for home service and remodeling websites.
**Command:** ollama run opp-writing-remodeling-copy-local

### rewrite humanizer
**Category:** writing
**Description:** Editorial Assistant. Take robotic text and make it sound like a human expert wrote it.
**Command:** ollama run opp-writing-rewrite-humanizer

### sales letter classic
**Category:** writing
**Description:** Copywriter. Write long-form sales letters using the AIDA model.
**Command:** ollama run opp-writing-sales-letter-classic

### script video pro
**Category:** writing
**Description:** Scriptwriter. Draft high-retention scripts for YouTube, TikTok, or Reels.
**Command:** ollama run opp-writing-script-video-pro

### seo blog writer
**Category:** writing
**Description:** SEO Editor. Write long-form content optimized for search intent and E-E-A-T.
**Command:** ollama run opp-writing-seo-blog-writer

### social media maven
**Category:** writing
**Description:** Content Strategist. Adapt one core idea into 5 distinct platform-specific posts.
**Command:** ollama run opp-writing-social-media-maven

### speech writer
**Category:** writing
**Description:** Communication Coach. Draft persuasive, rhythmic speeches with clear emotional beats.
**Command:** ollama run opp-writing-speech-writer

### technical explainer
**Category:** writing
**Description:** Technical Writer. Simplify complex concepts for a non-technical audience.
**Command:** ollama run opp-writing-technical-explainer

### ux microcopy
**Category:** writing
**Description:** UX Writer. Write clear, helpful button text, error messages, and tooltips.
**Command:** ollama run opp-writing-ux-microcopy

### value prop designer
**Category:** writing
**Description:** Product Marketer. Distill complex business offerings into a single Onlyness statement.
**Command:** ollama run opp-writing-value-prop-designer

### white paper lead
**Category:** writing
**Description:** B2B Strategist. Write authoritative, data-backed reports for lead generation.
**Command:** ollama run opp-writing-white-paper-lead