How Much RAM Do You Need for a Local LLM?
Updated
The number you need is not system RAM. It is the memory a model can actually occupy, which depends on the memory architecture of the machine, and on most hardware it is far lower than the figure on the box.
What is the formula?
A model's weights take its parameter count multiplied by the bits per parameter, divided by eight to get bytes. At Q4_K_M, the quantisation most people run, that is about 4.85 bits rather than a clean 4. Add roughly 15 percent for runtime overhead, then add memory for the context window, which starts around 2GB at an 8k context and scales from there.
In practice: an 8B model needs about 8GB, a 14B about 12GB, a 24B about 19GB, a 32B about 24GB, a 70B about 51GB, and a 120B about 86GB. Those are the numbers this site uses everywhere, so the figure on a system page and the figure here will always agree.
Why mixture-of-experts models are different
A mixture-of-experts model activates only some of its parameters per token, which makes it fast. It does not make it small. Every expert has to be resident in memory, so a 235B model with 22B active still needs room for all 235B. Treating the active count as the memory requirement is the single most common way people underestimate what they need.
How much do you actually need?
Decide the largest model you want to run, apply the formula, then add headroom. A machine with exactly the required memory will load the model and leave nothing for a long context, so this site treats a fit as comfortable only when there is at least 10 percent spare. Below that we label it limited, which means it will run with a reduced context or with some layers offloaded to the processor.
Does quantisation change the answer?
Substantially. The same 70B model needs about 51GB at Q4 and about 88GB at Q8. Q4_K_M is the usual choice because the quality loss is small for most work and the memory saving is close to half. Dropping below Q4 saves less than people expect and costs noticeably more quality.
What about the context window?
Context is the part people forget, and it is the part that grows. The key-value cache holds the conversation so far, and it scales with length: roughly 2GB at an 8k context on a mid-sized model, four times that at 32k, and more again on a long document. A model that fits comfortably in a short chat can exhaust memory halfway through a long one.
This matters most for agent work, where the context accumulates tool calls and file contents rather than a few sentences. If that is your use, budget for the context as a real line item rather than an afterthought, and treat the comfortable-fit threshold on this site as a floor rather than a target.
Does running more than one model change the answer?
Yes, and increasingly this is the normal case. A practical local setup often keeps a small fast model resident for routing or classification alongside the large model doing the work, plus an embedding model if you are doing retrieval. Each of those occupies memory simultaneously.
Add their requirements together rather than taking the largest. An 8B router at about 8GB alongside a 70B main model at about 51GB is close to 60GB before context, which pushes a 64GB machine to its limit and sits comfortably on a 96GB one.
How to check before you buy
Take the model you want, apply the formula, add your context, add any second model, then compare against the usable AI memory figure on the system page rather than the advertised RAM. Our Can This PC Run It tool does this arithmetic for you, and every system page lists the usable figure and the rule that produced it.
If the result is close, buy the larger configuration. Memory is soldered on most unified-memory machines, so this is a decision you make once.
Worked examples
Take three common targets. An 8B model at Q4 is about 4.9GB of weights, roughly 5.6GB with overhead, and about 7.6GB once an 8k context is included. Any machine with 12GB or more of usable AI memory handles it comfortably, which includes most Copilot-class laptops.
A 32B model is about 19.4GB of weights, roughly 22.3GB with overhead, and about 24.3GB with context. That needs 27GB to be comfortable by our 10 percent headroom rule, which rules out shared-memory laptops and puts you into discrete cards with 32GB or unified-memory machines.
A 70B model is about 42.4GB of weights, roughly 48.8GB with overhead, and about 50.8GB with context, so 56GB to be comfortable. No consumer graphics card reaches that, which is the single clearest hardware boundary in local AI today.
What we do not count
System RAM on a discrete-graphics machine is not AI memory. It allows offloading, which works and is slow, so we list it separately as CPU offload capacity rather than adding it to the headline figure. A machine advertised as having 64GB of RAM and a 16GB card has 16GB of AI memory on this site, and that is the number that predicts what it can run.
We also do not count memory that the operating system has reserved. Every figure on this site is what a model can actually occupy after the platform takes its share.
How we calculate the figures on this page
Every figure on this page comes from one rule applied consistently across the site. A model needs its parameter count multiplied by the bits per parameter of its quantisation, divided by eight, plus about 15 percent runtime overhead, plus the key-value cache for the context window. We treat Q4_K_M as 4.85 bits rather than four, because it keeps some tensors at higher precision internally and calculating at four understates the requirement by roughly a fifth. A fit is comfortable only with 10 percent headroom above that total, and limited between 80 and 110 percent, which is the range where a model runs with a shortened context or some layers offloaded to the processor. Below 80 percent we say it does not fit rather than implying it might. The usable AI memory figure we compare against is not the advertised RAM: it is what the memory architecture actually hands a model, which is the full VRAM on a discrete card, about three quarters of the pool on Ryzen AI Max and Apple silicon, the pool minus roughly 8GB on an NVIDIA GB10 machine, and about half on a shared-graphics laptop. Those rules are published in full on our AI memory page, and every system page prints the rule that produced its own figure. Nothing here is estimated from a benchmark or inferred from a product category, which is why the number on a system page and the number in this guide will always agree.
