The best PC build for local AI in 2026 is a single 16GB GPU with 64GB of system RAM, around $1,250. VRAM is the only spec that decides which models you can run at all: 16GB covers 7B–14B models at good quantization, 24GB reaches 34B, and a 70B model needs roughly 42GB — two cards, or one 32GB card plus offload.
Everything else in the build — CPU, RAM speed, storage — changes how fast the model loads, not how fast it thinks. Below are the VRAM numbers for every common model size, the quantization rules that decide them, and three anchored builds at $1,250, $2,400 and $4,200.
How Much VRAM Do You Need? Model Size × Quantization
For LLM inference, VRAM is everything. A model's VRAM requirement is its parameter count × bytes per parameter, and the quantization format sets that second number: FP16 is 2 bytes, Q8 is roughly 1.06, and Q4_K_M is roughly 0.55.
The table below is weights only. Add 1–3GB for the KV cache (the running context) and another ~1GB if the same card is driving your desktop.
| Model size | FP16 (full) | Q8 (near-lossless) | Q4_K_M (practical) | Card that fits Q4 |
|---|---|---|---|---|
| 7B | ~14GB | ~7.5GB | ~4.5GB | Any 8GB card |
| 13–14B | ~27GB | ~14GB | ~8.5GB | 12GB card (RTX 5070) |
| 34B | ~68GB | ~36GB | ~20GB | 24GB card (used RTX 4090) |
| 70B | ~140GB | ~74GB | ~42GB | 2× 24GB, or 32GB + offload |
| 120B+ (MoE) | ~240GB | ~128GB | ~70GB | 2× 32GB (RTX 5090) |
Read the table by row, not by column: almost nobody runs FP16 locally. The FP16 column is there to show what quantization buys you — a 70B model goes from "impossible on any desktop" to "two consumer cards" purely by changing the number format.
A Note on Quantization: Where the Quality Actually Goes
Quantization stores each weight in fewer bits. The naming follows llama.cpp's GGUF convention — the number is the bit width, and _K_M means a k-quant at medium precision, which protects the layers that matter most.
- Q8_0 is effectively indistinguishable from FP16 for chat and coding. Use it whenever the model fits.
- Q5_K_M is the quality floor most people cannot detect in normal use.
- Q4_K_M is the practical default. Perplexity rises slightly; instruction-following and code generation hold up well.
- Q3 and below is where it stops being free. Damage lands hardest on multi-step reasoning and long-context recall — exactly the abilities you wanted a bigger model for.
The rule that follows from this: a smaller model at higher precision beats a bigger model crushed into the same VRAM. A 14B at Q4_K_M is a better daily driver on a 16GB card than a 32B at Q3_K_M, even though both technically "fit."
Budget AI Build (~$1,250) — Run 7B–14B Models Locally
| Component | Pick | Price |
|---|---|---|
| CPU | AMD Ryzen 5 7600 | ~$169 |
| Motherboard | B650M, DDR5 | ~$130 |
| Memory | 32GB DDR5-5600 (memory) | ~$75 |
| Storage | 1TB NVMe + 4TB HDD (storage) | ~$130 |
| GPU | RX 9070 XT (16GB) | ~$549 |
| Case + PSU | mATX case + 650W Gold | ~$120 |
| Total | ~$1,173 |
The planner picks a model for each row that doesn't name one, so check those picks against this table. It lists any row it can't match.
The RX 9070 XT with 16GB GDDR6 is this build's anchor and the best VRAM-per-dollar in the video card catalog. It runs every 13B–14B model comfortably and handles some 20B models in aggressive quantization. ROCm support on Linux — and increasingly on Windows via the HIP SDK — has improved significantly; Ollama and LM Studio both support AMD GPUs natively.
What you can run on 16GB: Llama 3.1 8B (excellent quality), Mistral Nemo 12B, Phi-3 Medium 14B, and Qwen 2.5 Coder 14B for coding assistance. These are genuinely capable models for most day-to-day AI tasks.
Why the 4TB HDD: model files are large. Llama 3.1 70B Q4 is ~42GB on disk. If you are experimenting across several models, storage fills fast — keep active models on the NVMe and archive the rest.
Mid-Range AI Build (~$2,400) — 24GB, or 32GB Across Two Cards
| Component | Pick | Price |
|---|---|---|
| CPU | AMD Ryzen 9 9950X | ~$549 |
| Motherboard | X670E / X870E, dual x8 PCIe | ~$300 |
| Memory | 64GB DDR5-6000 | ~$190 |
| Storage | 2TB NVMe | ~$120 |
| GPU | used RTX 4090 (24GB) or RTX 5080 (16GB) | ~$1,000–1,800 |
| Case + PSU | Full ATX + 1000W Gold | ~$200 |
The planner picks a model for each row that doesn't name one, so check those picks against this table. It lists any row it can't match.
This is the tier where the buying decision gets interesting, and it comes down to one question: capacity or ecosystem?
A used RTX 4090 at 24GB is the single best value in local inference. That 24GB clears 34B-class models at Q4_K_M with room for a real context window — a jump in capability that no 16GB card reaches at any quantization. It is the card to buy if model size is the constraint.
A new RTX 5080 gives up 8GB of VRAM but returns a warranty, lower idle power, and the current-generation feature set. Choose it if you also game on this machine, or if buying a two-generation-old flagship second-hand is not something you want to underwrite.
Two 16GB cards reach 32GB combined and run 34B at Q5/Q6, but tensor-parallel inference over PCIe scales at roughly 1.6–1.8×, not 2×. One 24GB card is simpler, quieter, and usually faster than two 16GB cards for the same total spend.
High-End AI Build ($4,200+) — 32GB for 70B-Class Models
| Component | Pick | Price |
|---|---|---|
| CPU | AMD Ryzen 9 9950X | ~$549 |
| Motherboard | X870E, dual x8 PCIe | ~$449 |
| Memory | 64GB DDR5-6000 (128GB for offload) | ~$190–380 |
| Storage | 4TB NVMe | ~$300 |
| GPU | RTX 5090 (32GB) | ~$2,200 |
| Case + PSU | Full ATX + 1200W Platinum | ~$350 |
The planner picks a model for each row that doesn't name one, so check those picks against this table. It lists any row it can't match.
A single RTX 5090 at 32GB is the closest a one-slot consumer build gets to 70B-class models — but be precise about what "runs" means here. A 70B at Q4_K_M needs ~42GB, so it does not fit: roughly 12GB of layers execute on the CPU at DDR5 bandwidth instead of the card's 1.8TB/s. Nobody publishes a measured throughput figure for that exact spill on a single 5090 — the benchmark chart below is limited to models that fit in 32GB — but the bandwidth split alone puts generation in the low single digits of tokens per second, against the 61 t/s the same card manages on a 32B that fits. That is workable for batch summarisation and overnight document jobs, and slower than you read for interactive chat. The two ways out are both real trade-offs: drop to a ~3-bit quant (Q3_K_S or IQ3, ~31GB) so the whole model sits in VRAM and accept the quality loss flagged above, or add a second card and run it at Q4 across 64GB.
That offload path is why the Ryzen 9 9950X and a 64GB DDR5-6000 kit are specified here rather than the cheapest parts that boot. Offloaded layers execute on CPU cores at memory bandwidth, so core count and DDR5 speed set the floor on tokens/second for anything that does not fit in VRAM. Go to 128GB if you plan to run 120B-class MoE models with a large share of layers in system RAM.
Add a second 5090 only if you need 64GB — for fine-tuning, or for 70B at Q8. For inference alone, one 32GB card plus offload is the better-behaved machine.
For research and training workloads rather than inference, the AI and machine-learning workstation guide covers the different balance that training demands: more system memory, faster storage, and sustained multi-GPU cooling.
Best Local LLM for Coding on a 16GB VRAM GPU
16GB is the most common VRAM tier in 2026 — it is what an RX 9070 XT, an RTX 5080 or a mobile RTX 5090 all give you — and it is the tier where local coding assistants stop being a toy. Here is what actually fits, and what has to give.
The mistake people make is budgeting VRAM for the weights alone. A coding session is long: you paste a file, the model paraphrases it back, you iterate. That KV cache grows with context length, and on a 16GB card the context window is usually what pushes you out of VRAM, not the model.
| Coding model | Quant | Weights | Usable context on 16GB | Verdict |
|---|---|---|---|---|
| Qwen 2.5 Coder 7B | Q5_K_M | ~5.5GB | 32K+ comfortably | Best all-round starting point |
| Qwen 2.5 Coder 14B | Q4_K_M | ~9GB | 16–24K | Best quality that still fits well |
| DeepSeek Coder V2 Lite 16B (MoE) | Q4_K_M | ~10GB | 16K | Strong at repo-scale reasoning |
| Code Llama 13B | Q4_K_M | ~8GB | 16–32K | Older, still fine for completion |
| Qwen 2.5 Coder 32B | Q3_K_M | ~14GB | 8K, tight | Fits, but quality loss + slow |
The practical recommendation: a 14B-class coder at Q4_K_M is the sweet spot on 16GB. It leaves 5–6GB of headroom for a 16–24K context window, which is enough to hold a couple of real source files plus the conversation. Dropping to a 7B at Q5 buys you a much longer context and roughly double the tokens/second — worth it if you mostly want inline completion rather than architectural discussion.
Things that reclaim VRAM on a 16GB card:
- Quantize the KV cache (Q8 or Q4 KV cache in llama.cpp/Ollama) — often frees 2–4GB at long context for very little quality cost.
- Run headless. A desktop compositor and a browser can hold 1–2GB of your card hostage. On Linux, running the model on a second GPU-free session is the cheapest upgrade you'll ever make.
- Don't chase 32B. A 32B model squeezed into 16GB at Q3 is usually worse in practice than a 14B at Q4, because the quantization damage lands hardest on exactly the reasoning you wanted the bigger model for.
If coding is the primary job and AI is the side quest, the programming and software-development build balances compile throughput and VRAM better than a pure inference box. If you are deciding between two 16GB cards, the RTX 5070 vs RX 9070 XT comparison covers the CUDA-vs-ROCm trade-off that matters more for AI than it does for games.
Best Mini PC for Local LLMs in 2026
Mini PCs used to be irrelevant to this conversation — no room for a real GPU, so no VRAM, so no models. Unified-memory designs changed that. A mini PC with 64GB or 128GB of unified memory can load models that a $2,000 dual-GPU tower cannot, because the GPU addresses system memory directly instead of being capped by a soldered 16GB frame buffer.
The catch is bandwidth. Discrete GPU VRAM runs at 600–1,800 GB/s; unified memory in a small-form-factor box typically runs at 200–270 GB/s. Token generation is memory-bandwidth-bound, so the mini PC loads the 70B model the tower can't — and then generates at a fraction of the speed.
| Mini PC class | Memory | Realistic ceiling | Where it wins |
|---|---|---|---|
| Ryzen AI Max / Strix Halo class | 64–128GB unified | 70B at Q4, slowly | Biggest models per dollar, ~100W |
| Apple silicon Mac mini / Studio | 32–192GB unified | 70B–120B at Q4 | Best bandwidth-per-watt, MLX ecosystem |
| Intel NUC-class + eGPU | 8–16GB in the eGPU | 13B | Reuses a desktop GPU over Thunderbolt |
| Standard mini PC (iGPU only) | 32GB shared | 7B, CPU-speed | Not worth building for |
Pick a mini PC if: you want to run large models occasionally, you care about idle power and noise, and you're happy at 5–15 tokens/second on a 70B. That's fine for batch summarisation, document Q&A, or an always-on assistant. It is not fine for interactive pair-programming.
Pick a tower if: you want interactive speed, you want to fine-tune anything, or you want an upgrade path. A 16GB discrete GPU in the budget build above will beat any mini PC on 13B-class models by 3–5×, and you can add a second card later — something no mini PC lets you do.
Avoid the eGPU route unless you already own the GPU. Thunderbolt adds latency and costs you an enclosure; the same money in a small ATX tower buys more VRAM and better thermals. If small-and-quiet is the real requirement, a compact mini-ITX build gets you a full-size GPU in a case not much larger than a shoebox.
Laptops for Running Local AI & LLMs in 2026
The honest answer first: for the same money, a desktop will run bigger models faster, and it will keep doing it after ten minutes. Laptops are the right call when portability is a hard requirement — not when it's a preference.
What limits a laptop:
- VRAM is capped low. Mobile GPUs top out around 16GB in 2026 even at the flagship tier, so 13B–14B at Q4 is the realistic ceiling on a discrete-GPU laptop. There is no dual-GPU escape hatch.
- Sustained power, not peak. A mobile GPU rated at 175W in a thin chassis will settle far below that once the fans are saturated. LLM inference is a sustained load, so the number you actually get is the throttled one, and a thicker chassis with better cooling genuinely outruns a thinner laptop carrying the same GPU.
- Battery is not a factor. Inference on battery is heavily power-limited on nearly every machine. Plan to run plugged in.
The three laptop options that make sense:
- Unified-memory Apple silicon (MacBook Pro, 36–128GB). The strongest local-LLM laptop story in 2026: memory capacity a discrete mobile GPU can't match, good bandwidth, quiet, and excellent tokens-per-watt via MLX and Ollama. This is the machine to buy if you want to run 70B-class models on a plane.
- Discrete-GPU Windows/Linux laptop with 16GB VRAM. Best if you also game, need CUDA specifically, or want to fine-tune small models. Prioritise chassis thickness and a 16GB card over clock speed marketing.
- Any laptop plus a home server. Cheapest and, for most people, the correct answer: put the GPU in a tower at home running Ollama or vLLM, expose it over Tailscale or a VPN, and use whatever thin laptop you already own as the client. You get desktop-class model sizes anywhere with a network connection, and the laptop stays cool and quiet.
If option 3 appeals, the mid-range build above doubles as the server, and a NAS/home-server build covers the always-on side of the setup. For students who need one portable machine to do everything, the college build guide weighs the same trade-off across coursework, gaming and AI.
CPU, RAM, and Storage — What Actually Matters for LLM Inference
Once your model fits in GPU VRAM, CPU and RAM contribute minimally to tokens-per-second. They matter in these specific scenarios:
CPU matters for: initial model loading (decompressing quantized weights), tokenization speed, and CPU-offloaded inference — when the model does not fully fit in VRAM and some layers run on CPU. This is the case that justifies a Ryzen 9 9950X over a mid-range chip: offloaded layers are executed by CPU cores against system memory, so cores and memory bandwidth set the tokens/second floor for any model larger than your card.
RAM matters for: the operating system, model management software, and any CPU-offloaded layers. 32GB is fine for pure GPU inference. A 64GB DDR5-6000 kit is the right call the moment you intend to run a model larger than your VRAM, because the offloaded remainder has to live somewhere — and DDR5-6000 is meaningfully faster than DDR5-4800 for that specific job. Browse the memory category for current kits.
Storage speed matters for: model load times. NVMe loads a 13B model in 5–8 seconds versus 30–45 seconds on a SATA SSD. For frequent model switching, NVMe is worth it; for a single always-loaded model, even a SATA SSD is fine. Model libraries grow quickly, so size the storage generously — 2TB is a sensible floor once you keep more than a handful of models.
Software Setup: Ollama, LM Studio, and vLLM
Ollama is the easiest starting point. Install it, run ollama pull llama3.1, and you have a local model accessible via API at localhost:11434. It handles AMD and Nvidia GPUs automatically on Linux; Windows support has improved but occasionally requires ROCm tweaks for AMD.
LM Studio is the GUI option — excellent for testing models, adjusting context window size, and running models without touching the command line. It supports GGUF model format (the standard for quantized local models from Hugging Face). Works on Windows, Mac, and Linux.
vLLM is the production-grade option. If you're serving a model to multiple users or running a local API endpoint at scale, vLLM handles batching, continuous batching, and throughput optimization. It's primarily Linux/Nvidia-focused, though AMD ROCm support has improved.
For most users: start with Ollama or LM Studio. Graduate to vLLM if you need to serve requests to multiple applications or optimize throughput.
Why Build a Local AI PC? Privacy, Speed, and Cost Savings
The practical case for local AI in 2026 is stronger than it was two years ago. API costs for heavy usage run $20–100+ per month for power users. A local build amortizes those costs in months while delivering:
Privacy: every prompt runs on your hardware. Nothing goes to a third-party server. For legal documents, private code, medical notes, or anything you wouldn't want in a training dataset, local inference is the only safe option.
Speed: a well-sized local GPU runs 7B models at 40–80 tokens/second — faster than most API responses once you factor in network latency and rate limiting.
Customization: local models can be fine-tuned on your own data, run with persistent custom system prompts, and integrated into local workflows without API restrictions.
The trade-off: local models at 7B–14B parameters are genuinely useful but not frontier-class. Llama 3.1 70B and Qwen 2.5 72B close much of that gap, but running them well is what the $4,200 tier above exists for.
Ready to build a local AI workstation? Start your build on PlanMyPC to configure components with automatic compatibility checks, then confirm each part's price at the retailer before you order.