Best GPU for local AI

Which AI models can the Radeon RX 6650 XT run?

The Radeon RX 6650 XT has 8 GB of graphics memory, read at 280 GB/s. In a desktop with 32 GB of DDR4-3600, 29 of the 88 open models here run entirely on the card, 29 of them writing faster than you read; the most capable it runs well is Qwen3.5 9B at Q4_K_M, 30–48 tokens/s. 33 more run with part of the model in system memory, more slowly.

Every figure is for an 8,192-token conversation (about 6,000 words), at the best compression that fits. Try it in the calculator with your own memory, conversation length and compression, or a second card. For image and video models, see Stable Diffusion, FLUX and Wan on the Radeon RX 6650 XT.

Models that run entirely on the card

The fastest way to run a model: all of it in graphics memory. Most people read at 5 to 8 tokens a second, so anything above 10 feels quick.

Models the Radeon RX 6650 XT runs entirely on the card
ModelCompressionWritesNeeds
Qwen3.5 9BQ4_K_M30–48 tokens/s6.1 GB
Ornith 1.5 9BQ4_K_M30–48 tokens/s6.1 GB
Ministral 3 8BQ4_K_M30–48 tokens/s6.5 GB
Granite 4.2 8BQ4_K_M30–48 tokens/s6.7 GB
Qwen3 8BQ4_K_M32–52 tokens/s6.2 GB
DeepSeek R1 0528 Qwen3 8BQ4_K_M32–52 tokens/s6.2 GB
Llama 3.1 8BQ5_K_M29–46 tokens/s6.8 GB
Gemma 4 E4BQ6_K47–75 tokens/s6.7 GB
Qwen2.5 7BQ6_K28–45 tokens/s6.7 GB
Mistral 7B v0.3Q5_K_M32–51 tokens/s6.2 GB
Gemma 4 E2BQ8_070–115 tokens/s5.5 GB
Qwen3.5 4BQ8_035–57 tokens/s5.2 GB
Gemma 3 4BQ8_038–60 tokens/s4.9 GB
Qwen3 4B 2507Q8_037–59 tokens/s5.5 GB
Ministral 3 3BQ8_040–63 tokens/s5.0 GB
Phi-4-miniQ8_039–62 tokens/s5.2 GB
Granite 4.2 3BQ8_042–68 tokens/s4.6 GB
Llama 3.2 3BQ8_046–73 tokens/s4.4 GB
SmolLM3 3BQ8_050–79 tokens/s3.9 GB
Qwen3.5 2BQ8_071–115 tokens/s2.5 GB
Qwen3 1.7BQ8_067–105 tokens/s3.1 GB
LFM3 1.7BQ8_091–145 tokens/s1.9 GB
Llama 3.2 1BQ8_0115–185 tokens/s1.6 GB
Gemma 3 1BQ8_0150–240 tokens/s1.1 GB
Qwen3.5 0.8BQ8_0165–265 tokens/s1.0 GB
Qwen3 0.6BQ8_0130–210 tokens/s1.7 GB
SmolLM2 360MQ8_0265–425 tokens/s0.7 GB
LFM2.5 350MQ8_0325–520 tokens/s0.5 GB
Gemma 3 270MQ8_0405–650 tokens/s0.3 GB

With help from system memory

In a desktop with 32 GB of DDR4-3600, these fit with part of the model in system memory. The processor reads that part several times more slowly, so they write more slowly the more of them is off the card.

Models the Radeon RX 6650 XT runs with part in system memory
ModelOn the cardWritesNeeds
Mistral Medium 3.5 128B24%1.2–1.9 tokens/s28 GB
Qwen3.5 122B-A10B27%15–24 tokens/s25 GB
Nemotron 3.5 Super 120B-A12B27%13–21 tokens/s25 GB
Mistral Small 4 119B28%23–36 tokens/s24 GB
GLM-4.5 Air 106B-A12B21%7.6–12 tokens/s32 GB
Llama 4 Scout 109B-A17B29%8.0–13 tokens/s23 GB
Qwen3 Coder Next 80B-A3B23%24–38 tokens/s30 GB
Nemotron 3.5 Bolt 74B-A9B24%9.3–15 tokens/s28 GB
Qwen2.5 72B23%1.1–1.8 tokens/s30 GB
Llama 3.3 70B23%1.2–1.9 tokens/s29 GB
Flint 40B-A2.5B28%19–31 tokens/s24 GB
Qwen3.6 35B-A3B31%17–28 tokens/s22 GB
Qwen3 32B31%1.7–2.7 tokens/s22 GB
Nemotron 3.5 Lightning 30B-A3B35%19–30 tokens/s19 GB
Gemma 4 31B34%1.8–2.9 tokens/s20 GB
GLM-4.7 Flash35%17–27 tokens/s19 GB
Qwen3 30B-A3B 250735%15–23 tokens/s19 GB
Qwen3 Coder 30B-A3B35%15–23 tokens/s19 GB
Muse Glimmer 30B37%2.1–3.3 tokens/s18 GB
Granite 4.2 30B34%1.9–3.1 tokens/s20 GB
Qwen3.6 27B39%2.3–3.6 tokens/s17 GB
Qwen3.8 27B39%2.3–3.6 tokens/s17 GB
Gemma 3 27B38%2.2–3.5 tokens/s18 GB
Gemma 4 26B-A4B43%15–24 tokens/s16 GB
Mistral Small 3.2 24B43%2.7–4.3 tokens/s16 GB
Devstral Small 2 24B43%2.7–4.3 tokens/s16 GB
LFM2.5 24B-A2B46%25–40 tokens/s15 GB
gpt-oss 20B55%21–34 tokens/s12 GB
Qwen3 14B66%6.2–9.9 tokens/s10 GB
Phi-464%5.9–9.5 tokens/s11 GB
Ministral 3 14B69%7.0–11 tokens/s9.8 GB
Gemma 3 12B82%11–18 tokens/s8.3 GB
Gemma 4 12B89%14–23 tokens/s7.7 GB

The other 26 need more memory than a desktop with 32 GB of DDR4-3600 has; the calculator shows what more memory, or a second card, would add.

Two Radeon RX 6650 XTs

Two of them pool 16 GB, enough for 43 of the models entirely on the cards, 14 more than one holds. The most capable that runs well is Qwen3 14B at Q6_K, 14–23 tokens/s. A second card adds memory, not speed: a model that already fits on one runs no faster on two.

Compared with similar graphics

Tokens per second writing Llama 3.1 8B at 4 bits, which every 8 GB card holds, and the most capable model each runs well on its own. Every card ranked.

GraphicsMemoryLlama 3.1 8BMost capable it runs well
Radeon RX Vega 648 GB45Qwen3.5 9B
P102-100 (mining card)10 GB45Gemma 3 12B
GTX 1080 Ti11 GB45Ministral 3 14B
Radeon RX 6650 XT8 GB44Qwen3.5 9B
RTX 4000 Ada20 GB44Muse Glimmer 30B
RTX 40608 GB44Qwen3.5 9B
RTX 2060 SUPER8 GB43Qwen3.5 9B

Estimated tokens per second; a real figure is usually within a quarter either way. * Part of it in system memory. {CAPABLE_NOTE}

How it is worked out

Writing an answer is limited by memory rather than arithmetic: for every word-piece (token) a model writes, the computer reads every weight that token uses once. So the speed is how fast the memory holding the model can be read, divided by how much is read for each token: the model’s weights at the chosen compression, plus the conversation so far. How much of its memory speed each graphics card reaches is measured, not assumed: it comes from the card’s own result in llama.cpp’s benchmark, which LM Studio, Ollama and Jan are built on. A model that does not fit in the graphics card’s memory spills into system memory, five to fifteen times slower, and one that does not fit in memory at all can be read from the drive as it runs, slower again; the estimate counts each part at its own speed, and a processor with few threads cannot use all of fast memory. Graphics built into a processor use system memory, at its speed. Reading a prompt is limited by arithmetic, so it follows the measured prompt speed.

Already running a model? See if it runs at full speed

A model that is slower than it should be is nearly always partly on the processor rather than all on the graphics card, which is several times slower — and Ollama does that without a word when something else holds the card’s memory. Bottleneck’s free app checks a model run with Ollama, LM Studio, llama.cpp, KoboldCpp or Jan: where it really runs, how fast it writes, and what your PC should manage with it. Nothing leaves your PC. Or check and fix it by hand.

It reads your parts too: the graphics card and how much memory it really has free, how much system memory is installed, the speed it runs at and in how many channels. Memory left in one channel, or below its rated speed, halves how fast a model runs from it, and Bottleneck says so. Its AI models screen then lists what runs on this PC.

The free version shows where a model runs and how fast, with no time limit and no account. Pro, $9 once, explains why it is slower than it could be and how to fix it. Compare the versions