What Local LLM Fits My Machine? VRAM + RAM Lookup for Every Common Setup (July 2026)

Bottom Line (July 2026)

• Discrete GPU? Your VRAM is the budget. System RAM does not add to it. A 12GB card with 128GB of RAM is a 12GB machine for fast inference.
• Apple Silicon? Your unified memory is the budget. One pool, shared by CPU and GPU, most of it usable by the model.
• Multiple NVIDIA cards do add up. Two 32GB cards give 64GB for LLMs. This is not like image generation, where they do not.
• Context is not free. The KV cache lives in the same memory as the weights, so a model that loads at 4K context can fail at 64K.
• The honest floor for agentic coding is about 12GB VRAM, and it only gets comfortable at 24GB. Below that, run chat locally and send agent loops to a cloud model.

First, Answer the Question Everyone Gets Wrong

The single most common question in local LLM threads is some version of: “I have 64GB of RAM and a 4090 — do I add the GPU memory and the regular memory together?”

On a discrete GPU, no. The model runs fast only when its weights sit in VRAM. Your 4090 gives you 24GB, and the 64GB of system RAM behind it does not extend that budget. What system RAM does give you is two things:

1. CPU offload. llama.cpp will happily put the layers that do not fit into system RAM and run them on the CPU. It works, and it is slow — you drop from GPU memory bandwidth to system memory bandwidth on every offloaded layer. Useful for a one-off run, not for a daily driver.
2. MoE expert offload. This one is genuinely worth using. Mixture-of-Experts models activate only a fraction of their parameters per token, so a runtime can keep the hot path on the GPU and park inactive experts in system RAM. It is the reason a big MoE can be tolerable on a modest card when a dense model of the same size is not. The extreme version of this idea — streaming a 160GB MoE through 8GB of VRAM — is still experimental and measured in minutes per answer.

On Apple Silicon, yes — sort of. Unified memory is one pool shared by the CPU and GPU. A 64GB Mac Studio really does let a model use most of that 64GB, at roughly 400 GB/s. That simplicity is the Mac’s advantage. The tradeoff is bandwidth: an RTX 5090 moves 1792 GB/s, which is why the same model generates several times faster on the GPU rig.

Two NVIDIA cards do add up for LLMs. Two RTX 5090s give 64GB. llama.cpp splits layers across both automatically, and vLLM runs tensor parallelism with --tensor-parallel-size 2. People coming from image generation expect this not to work, because there it does not. Here it does — with a PCIe tax on every token, so a model that fits inside one card still beats the same model split across two. Details in the 64GB VRAM guide.

The Lookup Table

Find the row that matches what you own. The pick is the model that fits with room to work, not the largest thing that technically loads.

If Your Machine Is a Spec Dump

The real posts look like “i9 14th gen, 128GB RAM, RTX 3060 12GB — can this run Qwen 3.6?” Here is how to read your own specs.

Find the GPU line first. If it names an NVIDIA or AMD card, look up that card’s VRAM and use only that row of the table. The i9 and the 128GB are not part of the model budget. For that exact machine: 12GB is the row, so Qwen 3.6 27B at Q4_K_M (16.8GB) does not fit, and Qwen 3.5 9B at Q6 does.

Then check whether the system RAM buys you anything. It does if you plan to run a large MoE with expert offload, or if you are willing to eat CPU-offload speeds for a bigger model occasionally. It does not change which model runs fast. We have dedicated pages for the two most-searched combinations: 128GB RAM + 24GB VRAM and 64GB RAM + 24GB VRAM. In both cases the GPU sets the tier and the RAM sets how many other things you can run beside it.

No discrete GPU at all? Then system RAM really is your budget, and CPU memory bandwidth is your speed limit. That is a different setup with different answers: 128GB RAM and no GPU.

On a Mac, there is only one number. Take your unified memory, use that row, and leave roughly 8–12GB for macOS and everything else you have open.

Context Eats Memory Too

The number people forget. Your weights are only part of the bill — the KV cache holds the attention state for every token in your context window, and it lives in the same memory as the model.

Laguna XS 2.1 makes the point cleanly. The Q4_K_M weights are 20.27GB either way, so it fits both a 24GB card and a 32GB card. On 24GB you have about 4GB left over, which caps practical context near 8–16K tokens. On 32GB you have about 12GB left, which holds roughly 64K. The model’s native window is 256K; neither card reaches it. The card is the ceiling, not the model. That is the whole 24GB vs 32GB comparison in two sentences.

Two practical consequences:

• A model that loads is not a model that works. Fitting the weights at 4K context tells you nothing about whether it survives a long agent run.
• If generation suddenly crawls, the cache spilled. It did not crash, it fell back to system memory. Drop the context window one notch. More failure modes in why local LLMs are slow even when they fit.

Cap the window explicitly rather than letting it find the ceiling on its own:

OLLAMA_CONTEXT_LENGTH=16384 ollama serve

The Honest Floor for Agentic Coding

“8GB VRAM with some success for agentic coding?” comes up constantly. The honest answer is that below about 12GB VRAM, agentic coding is rough, and 8GB is not a place to start.

Here is what changes as you climb:

• 8GB VRAM — a 4B to 8B model at Q4. Fine for chat, summarizing, and simple scripted work. Tool calling at this size is unreliable, and an agent loop that cannot be trusted to emit valid tool JSON is worse than no agent.
• 12GB VRAM — the floor. Real work happens, but a 20B model at Q4 fills the card and starves context, which makes it a poor agent host. Good local assistant, weak autonomous agent.
• 16GB VRAM — gpt-oss 20B at Q4 runs, and its tool-call output is the cleanest of the open-weight models. Light agent work is genuinely usable here.
• 24GB VRAM — the first comfortable tier. Qwen 3.6 27B at Q4 or Laguna XS 2.1 at Q4 with a working context window.
• 32GB VRAM and up — context stops being the constraint before quality does.

If you are under the floor, the right move is not to fight it. Run a small model locally for chat and point OpenClaw at a cloud model for the agent loop. That is a normal, sane setup, and it costs less than a GPU.

Five Mistakes That Cause Most “It Doesn’t Work” Posts

1. Adding VRAM and system RAM together. On a discrete GPU they are separate budgets. Only Apple Silicon shares one pool.
2. Buying more system RAM to run a bigger model. It buys headroom for OpenClaw, tools, and offload experiments. It does not raise your fast-model tier. Buy VRAM.
3. Sizing the model without sizing the context. Add the KV cache before you decide it fits.
4. Assuming a bigger card unlocks a bigger quant. Going from 24GB to 32GB does not unlock Q8 on Laguna XS 2.1 — the Q8 weights are ~33–36GB. It unlocks context.
5. Reading a unified-memory guide and buying GPUs. The model lists differ. A 57.6GB model on a 64GB Mac is one pool; on two 32GB cards it has to be split.

Related Guides

• Best local LLM by GPU — per-card picks for every NVIDIA and Apple tier
• Best local LLM by RAM — the unified-memory version of this lookup, 8GB to 128GB
• Best local LLM for 64GB VRAM — multi-GPU, tensor splitting, and why VRAM is not RAM
• Laguna XS 2.1 on 24GB vs 32GB — the clearest example of context, not weights, being the constraint
• Can 24GB VRAM run a 70B model? — the most-asked squeeze question
• Why local LLMs are slow even when they fit — cache spills and other quiet failures
• Can I run OpenClaw with 8GB RAM and 8GB VRAM? — the bottom tier, answered honestly