Best Local AI Models by VRAM and Memory: 8GB to 512GB (2026)

Last updated September 5, 2026

The best verified local AI models right now: Gemma 4 12B on 16 GB machines, Qwen3.8-27B on a 24 GB card, DeepSeek V4-Flash 0731 or Step 3.7 Flash on 128 GB of unified memory, and GLM-5.3 if you own server-class capacity. Four of the six tier picks changed over the summer; the field moved, and this page moved with it. Find your memory number below. Every claim carries its source and date, and every pick is re-verified on a schedule against its repository, license file, and runtime support. If you have not picked hardware yet, start with our local AI hardware guide, then come back for the software side.

Key Takeaways

• The verified picks by tier, September 2026: Gemma 4 12B for 16 GB, Qwen3.8-27B for 24 to 32 GB, DeepSeek V4-Flash 0731 and Step 3.7 Flash sharing the 128 to 256 GB tier, and GLM-5.3 at 384 GB and up now that its weights are public.
• Total parameters set your memory bill; active parameters only set speed. A model's quantized file size is your floor, and roughly 0.6 GB per billion parameters is the Q4 rule of thumb.
• This page replaces two earlier guides at one permanent address and is re-verified on a dated schedule. Sizes marked "measured" come from official or Unsloth repositories; the rest use the 0.6 GB rule.

Jump to your tier: 8 to 12 GB, 16 GB, 24 to 32 GB, 48 to 96 GB, 128 to 256 GB, 384 GB and up, or the vetting checklist.

How to Read the Tiers

Three kinds of memory can hold a model: dedicated GPU VRAM, unified memory on Apple Silicon and AMD's Ryzen AI Max platforms, and plain system RAM. The same two rules govern all of them. First, total parameters set your memory requirement, because every expert in a mixture-of-experts model must be resident for routing to work; the active count only sets generation speed. When a spec sheet leads with the active number, find the total before you plan a purchase. Second, a model's quantized file size is your floor, before the operating system, the runtime, and your conversation context take their share. Quantization to roughly 4-bit (Q4) cuts memory to about a quarter of trained precision with minor quality loss for most work, about 0.6 GB per billion parameters. The mechanics behind modern compression live in our TurboQuant explainer.

8 to 12 GB: Entry GPUs and Older Cards

The pick is LFM2.5-8B-A1B from Liquid AI: a sparse MoE with 8.3 billion total parameters and 1.5 billion active, unusually fast on modest hardware, with a 128K context and built-in step reasoning. At Q4 it occupies roughly 5 GB, leaving real context headroom even on an 8 GB card. One flag before you build on it: the LFM Open License v1.0 is Apache-based but limits free commercial use to companies under $10 million in annual revenue. For personal use and homelabs it changes nothing; above that line, you need a paid license. Google's Gemma 4 E4B is the clean Apache 2.0 alternative at this size, at 4.5 GB by Google's own Q4 loading table. The hardware anchor remains the 12 GB RTX 3060 class, still the cheapest reliable on-ramp to GPU-accelerated local AI.

Check Price on Amazon: RTX 3060 12GB

16 GB: The Laptop-Class Sweet Spot

The pick is Gemma 4 12B Unified: a dense model handling text, images, audio, and video in one encoder-free architecture, with a 256K context window and day-one support in Ollama, LM Studio, and llama.cpp. At Q4 it loads in 6.7 GB per Google's published memory table, a figure that already includes about 20 percent loading overhead, so long contexts fit comfortably on a 16 GB machine. The license is the other half of the story: Apache 2.0, a meaningful shift from the restrictive terms that governed earlier Gemma generations. If you want more capability in the same footprint, Gemma 4's 26B A4B mixture fits at 14.4 GB per Google's table and is the best per-gigabyte model available on a 16 GB machine. For coding-focused work at this size, JetBrains' Mellum2 posts the strongest self-reported LiveCodeBench score in class, with the standing caveat that its custom MoE architecture has run rough in Ollama and vLLM remains its supported path; verify current status before standardizing on it.

Check Price on Amazon: RTX 4060 Ti 16GB

24 to 32 GB: Qwen3.8-27B, With Two New Alternates

The pick changed on August 14. Qwen3.8-27B is Alibaba's dense 27.78B model under Apache 2.0: natively multimodal across text, images, and video, with a 262K context window and vendor-reported jumps over its predecessor (Terminal-Bench 2.1 rising from 63.4 to 73.0 and SWE-bench Pro from 53.5 to 61.7). Those are Alibaba's numbers, not independent reproductions; the early third-party datapoint is BenchLM's aggregate board, which ranks it second among all open-weight models with supported evidence. At the house Q4 rule it lands around 16 to 17 GB, fitting a 24 GB card with comfortable context. Our Qwen3.8-27B hardware guide has per-machine speeds.

Two alternates shipped the same week and each wins on one axis. Nvidia's Nemotron 3.5 Lightning is a 30B MoE with only 3B active parameters under OpenMDW-1.1, shipped pre-quantized to NVFP4, and it is the pick when latency matters more than peak capability: many short agent steps rather than a few long ones. Meta's Muse Glimmer 30B is a dense Apache 2.0 model tuned for tool-use reliability, with a bundled speculative decoder that Meta measures at 3.1x decode speed on an RTX 5090; at 4-bit it fits under 20 GB. Until independent benchmarks accumulate for all three, Qwen3.6-27B remains the proven fallback with GGUF builds that run everywhere. If your 32 GB is system RAM on an iGPU mini PC, Liquid AI's LFM2-24B-A2B was designed for exactly that fit, with the same revenue-clause flag as its smaller sibling.

The hardware anchors: the renewed RTX 3090 for GPU builds, still the value king of local AI, and the 32 GB mini PC class for an always-on box. Our mini PC guide for local AI covers setup and network isolation.

Check Price on Amazon: RTX 3090 24GB (Renewed)

Check Price on Amazon: Beelink SER9 PRO+ (32GB)

48 to 96 GB: Agents With Room to Breathe

The pick is Nex-N2-mini, a post-train of Qwen3.5-35B-A3B under Apache 2.0 from a lab with a published research paper behind its method. It technically squeezes onto a 24 GB card at a tight Q4 near 20 GB, but it belongs here, where higher-precision quants and long agentic contexts have room. Two standing flags: its benchmark numbers are self-reported on the lab's own suite, and Nex recommends serving through its customized sglang stack, so budget an evening, not ten minutes. The smoother-running alternatives are Gemma 4's 31B dense at 17.5 GB, or a 70B-class dense model when knowledge depth matters more than speed. The hardware anchor is the 64 GB unified-memory mini PC, quietly the best dollars-per-capability play for local agents. With DRAM at multi-year highs, machines shipping with memory installed beat build-it-later plans.

Check Price on Amazon: MINISFORUM X1 Pro 370 (64GB)

128 to 256 GB: Two Picks for Two Jobs

Unified memory's tier has two verified picks, split by job rather than ranked. For text and agent work, DeepSeek V4-Flash 0731: 284B total with 13B active, agent-tuned official weights since July 31, a measured quality ladder from 78 percent at 2-bit to lossless at 8-bit, and the widest runtime support in class. Mainline llama.cpp, LM Studio, and Unsloth Studio all load its 103 GB 3-bit build on a 128 GB machine. Our V4-Flash reality check carries the full tier map. For multimodal work, Step 3.7 Flash from StepFun: a 196B-backbone MoE activating about 11B per token, native image and video understanding, Apache 2.0, and official GGUF builds with measured sizes: 75.8 GB at IQ3_XXS, 103 GB at Q3_K_L, 111 GB at Q4_K_S, with llama.cpp in StepFun's own supported list and 128 GB devices named as deployment targets.

Two watch entries. GLM-5.3-Flash, released August 26 under MIT with native multimodality and a 1M context, is 320B total with 18B active; community measurements put it at roughly 105 to 115 GB with Unsloth's 2-bit dynamic quants and 180 to 195 GB at a proper Q4, so it is a 256 GB model at good quality and a 128 GB model only at the aggressive end. Tooling is still fork-only. Our GLM-5.3-Flash reality check tracks its runtime ledger; it earns a pick slot here the day mainline support lands. Qwen3.8-Flash-Next (August 26, 125B total with 6B active) reports 62.5 percent on SWE-bench Pro and should fit a 128 GB machine at Q4 with room to spare, but it is too new for measured GGUF sizes or a license review.

The hardware this tier runs on got a fresh entrant on August 25: Apple's M5-generation Mac Studio puts 128 GB on the M5 Max from $2,499 and 256 GB on the M5 Ultra shipping September 22. Our M5 wait-or-buy breakdown runs that math against the Ryzen AI Max+ 395 class, where the GMKtec EVO-X2's 128 GB configuration remains the value entry.

Check Price on Amazon: GMKtec EVO-X2 (128GB)

384 to 512 GB: The Open Flagship Tier

The pick updated again. GLM-5.3 is now the open-weight flagship worth housing: a post-train of the GLM-5.2 base (about 744B total with 40B active per Z.ai's documentation, 1M context) with a claimed 50 percent coding improvement, and its weights opened on Hugging Face on August 28 under an MIT-style license after a deliberate safety hold. Because the base is identical, the hardware math carries over: plan around 410 to 420 GB at Q4, family-scaled, and expect the community GGUF ladder to fill in over September. GLM-5.2 remains the proven quantity with a complete quant ladder if you need something that runs today. We covered the family's trajectory in our GLM-5.1 analysis. The Apache-licensed alternative is Nex-N2-Pro at 397B with 17B active, roughly 220 GB at Q4, with the same self-reported-scores flag as its smaller sibling.

Above this tier sit the models you can license but not house: Kimi K3 at 2.8 trillion parameters under its revenue-gated custom license (our K3 reality check priced the cluster), Qwen3.8-2.4T-A95B, and DeepSeek V4-Pro at 1.6 trillion. All three publish downloadable weights, and none runs on anything a household owns. Downloading is free; the silicon and the electricity are not.

How to Vet a Model Before You Run It

Hugging Face hosts hundreds of new releases and fine-tunes weekly. Model weights are passive data files, so the risk is rarely malware; the risk is trusting capability claims that were never real. Before you download:

1. Confirm the base model and its license. A fine-tune inherits its base's terms. If the card does not state the base, stop. Two models from the same announcement can carry different licenses; the Qwen3.8 pair does. Our open-source LLMs guide breaks down what each license pattern allows.
2. Check who ran the benchmarks and on how many samples. A score from a 350-question slice is a signal, not a result. Vendor and author numbers are marketing until independently reproduced, the rule this page applies to Qwen3.8-27B above.
3. Look for published evaluation logs and training-data disclosure. Authors who show their work earn more trust than a leaderboard screenshot.
4. Check tooling support. GGUF builds that load in Ollama or LM Studio mean low friction. A custom serving fork means you are the QA department.
5. Weight independent results over self-reported ones. If a model claims frontier wins and no third party confirms after weeks, that silence is data.
6. If you cannot verify it exists as described, skip it. The same discipline you would apply to firmware from an unknown source.

Once a model passes, our zero-cost local agent stack guide covers turning it into something useful.

Where the Closed Frontier Fits

Nothing on this page matches Claude Fable 5.1 or Opus 5 on the hardest long-horizon work, and pretending otherwise would insult your intelligence. On everyday coding the gap is now small: Qwen3.8-27B, the 24 GB pick above, scores above GPT-5.5 on SWE-bench Pro by vendor numbers, and the largest open weights sit above GPT-5.6 and Claude Sonnet 5. The full open-versus-closed comparison, and what the June Fable 5 blackout taught about rented capability, is in our best open-source LLMs guide. Every model on this page is the opposite arrangement: weights on your disk, terms that cannot change underneath you, no usage meter, nothing leaving your network.

All Picks at a Glance

Sizes marked "measured" come from official or Unsloth repositories; others use the 0.6 GB-per-billion Q4 estimate. Add several GB for context. Verified September 5, 2026.

Frequently Asked Questions

What is the best local AI model for 16 GB of RAM or VRAM?

Gemma 4 12B Unified: dense, multimodal across text, image, audio, and video, 256K context, Apache 2.0, and 6.7 GB at Q4 by Google's own loading table, leaving real context room on a 16 GB machine. Gemma 4 26B A4B fits the same tier at 14.4 GB with more capability and less headroom. The stronger Qwen3.8-27B needs a 24 GB card.

What is the best model for a 24 GB GPU in 2026?

Qwen3.8-27B, released August 14 under Apache 2.0: dense 27.78B, natively multimodal, 262K context, roughly 16 to 17 GB at Q4. Nemotron 3.5 Lightning is the alternate when speed matters more than capability, and Muse Glimmer when tool-use reliability does. All three carry vendor-reported benchmarks awaiting independent reproduction, so Qwen3.6-27B remains the proven fallback.

Can I run DeepSeek V4 at home?

V4-Flash, yes. Since July 2026 it is the recommended pick for 128 GB machines, with the 103 GB 3-bit build loading in mainline llama.cpp, LM Studio, and Unsloth Studio, and the agent-tuned 0731 weights downloadable since July 31. V4-Pro at 1.6 trillion parameters remains data-center hardware by any definition.

Can I run GLM-5.3 at home?

Not the full model; at 744B total it needs 384 GB and up even at Q4. GLM-5.3-Flash (320B total, 18B active) is the home-adjacent version and fits a 256 GB Mac Studio at Q4 or a 128 GB machine only at aggressive 2-bit quantization, with fork-only tooling for now. Our GLM-5.3-Flash reality check tracks when mainline runtimes catch up.

What is the difference between total and active parameters?

Total parameters are everything the model stores; active parameters are the subset used per token. Active count determines speed. Total count determines memory, because the entire model must be resident for expert routing to work. When evaluating any MoE model, find the total parameter count first; it is the number your hardware pays for.

Are community fine-tunes from Hugging Face safe to download?

Model weights are passive data files, not executable code, so malware risk from the weights themselves is low. The real risk is unverified capability claims. Check the base model, the license, who ran the benchmarks and on how many samples, and whether independent results exist before relying on one. The checklist above walks each step.

Should I wait for cheaper RAM before trying local AI?

No. Start with the memory you have. Models are improving faster than memory is getting cheaper, which means your current machine runs better AI every quarter without a hardware change. Four of this page's six tier picks changed in one summer. Upgrade when a specific model you want demands it, not in anticipation.