Jul 23, 2026

AMD Radeon AI PRO R9700 for Local AI in 2026: 32GB for $1,299 and the Real tok/s Numbers

By RunAIHome Team · 13 min read

amdr9700rdna4rocmgpulocal-llmhardware-guide

TL;DR: The Radeon AI PRO R9700 gives you 32GB of VRAM at $1,299 MSRP — more memory than an RTX 4090 for roughly half of what a used 4090 costs in July 2026. On MoE models it delivers 127–156 tok/s in llama.cpp, genuinely fast. The catch is prompt processing (2.6–3.4× slower than NVIDIA) and an ecosystem where Ollama still needs a workaround.

	Radeon AI PRO R9700	Used RTX 3090	Used RTX 4090
Best for	Biggest VRAM per dollar, new with warranty	Cheapest 24GB, raw bandwidth	Fastest single card under $3K
VRAM / bandwidth	32GB / 640 GB/s	24GB / 936 GB/s	24GB / 1,008 GB/s
Price (Jul 2026)	$1,299 MSRP, $1,403+ resale	~$1,252 avg	~$2,150–$2,350
The catch	Slow prefill, Ollama needs Vulkan flag	No warranty, 4-yr-old silicon	Costs ~$900 more for 8GB less

Honest take: If your daily models are MoE (Qwen3.6-35B-A3B, Gemma 4 26B) and you run llama.cpp on Linux, the R9700 is the best new-in-box value in local AI right now. If you live in dense 30B+ models, long prompts, or CUDA-only tooling, a used RTX 3090 is still $50 cheaper and less friction.

AMD reused its most beloved product name — the 9700 Pro that beat NVIDIA in 2002 — for a workstation card aimed squarely at home-lab AI builders. The R9700 shipped in system-integrator workstations on July 23, 2025, trickled into DIY retail through the fall, and spent early 2026 sold out or scalped. A year later the picture has changed: ROCm 7.2 made RDNA4 a first-class citizen, llama.cpp performance data is now abundant, and cards are intermittently in stock at MSRP. This is the guide to whether it deserves your $1,299.

One correction before the numbers, because several aggregator posts get this wrong: the R9700 uses GDDR6, not GDDR7, on a 256-bit bus at 20 Gbps — 640 GB/s of bandwidth, per AMD’s own datasheet. If you see “32GB GDDR7” or “576 GB/s” in a spec table, close the tab.

What the R9700 actually is

It’s a Radeon RX 9070 XT with double the memory and a blower. Same Navi 48 die, same 64 RDNA4 compute units and 4,096 stream processors, same 256-bit bus — but 32GB of GDDR6 in clamshell configuration instead of 16GB, a 300W board power target, PCIe 5.0 x16, and a dual-slot blower cooler designed to stack in multi-GPU chassis.

Spec	Radeon AI PRO R9700
Architecture	RDNA 4 (Navi 48, gfx1201)
Compute units / stream processors	64 / 4,096
AI accelerators	128 (2nd gen)
VRAM	32GB GDDR6, 256-bit @ 20 Gbps
Memory bandwidth	640 GB/s
Peak FP16	96 TFLOPS
Peak INT4 (sparse)	1,531 TOPS
Board power	300W
Interface	PCIe 5.0 x16
MSRP / partner range	$1,299 / $1,244–$1,329

Pricing at launch ran $1,244 (Sapphire) to $1,329 (ASRock Creator on Newegg), with most partner cards — Sapphire, Gigabyte AI TOP, PowerColor, XFX, ASUS — clustering at $1,299. As of July 2026, stock is inconsistent: Newegg listings flip between $1,299 and out-of-stock, and secondary-market listings run $1,403–$2,500 across 13 active listings tracked by GPU Poet. If you can get one at MSRP, that’s the deal; paying $1,700+ resale erases the card’s entire value argument.

The 300W TDP is worth pausing on. At the 18.8¢/kWh U.S. residential average (EIA, 2026), a fully loaded R9700 costs about $0.056/hour to run — and 300W is 50W less than a used RTX 3090 under load, on a card that idles like a modern GPU should. For a 24/7 home server, that difference compounds.

Why 32GB changes what you can run

LLM decode speed is memory-bandwidth-bound, but what you can run at all is VRAM-bound. The jump from 24GB to 32GB matters less for loading bigger models than for running the models you already use without compromises:

Model	Q4_K_M footprint	On 24GB (3090/4090)	On 32GB (R9700)
Qwen3.6-35B-A3B MoE	~22GB	Fits, ~8–16K context only	Fits with full context headroom
Gemma 4 31B (QAT)	~18GB	Fits	Fits + room for a draft model
Codestral 2 22B at Q8_0	~23.6GB	Doesn’t fit with KV cache	Fits
Llama 3.3 / dense 70B	~42.5GB	Partial offload, 8–15 tok/s	Still doesn’t fit — needs 2 cards

That third row is the underrated one: 32GB lets you step up a quant level (Q6, Q8) on the 20–35B class instead of squeezing Q4 in with a starved KV cache. We covered why 24GB cards choke on exactly this in our 70B-on-24GB guide — the R9700 doesn’t solve 70B either (42.5GB is 42.5GB), but two R9700s at $2,598 give you 64GB of warrantied VRAM, which is the cheapest new-hardware path to full-GPU 70B Q4 right now.

The real benchmark numbers

This is the section AMD buyers never used to get. RDNA4’s first year produced actual, reproducible llama.cpp data — here’s what the community has measured on the R9700, all on llama.cpp with the card fully loaded.

MoE models are where it shines. On Qwen3.5-35B-A3B (UD-Q4_K_XL, 3.5B active parameters), a llama.cpp benchmark thread measured 127.4 tok/s decode on the R9700 via Vulkan. A follow-up RDNA4 tuning thread pushed the same class of workload from 147.8 tok/s (stock RADV driver) to 156.3 tok/s with the AMDVLK driver plus a VGPR-pressure patch. For context, an RTX 5090 does 194 tok/s on the identical model — 1.52× faster, at roughly 2.7× the price ($4,300 vs ~$1,600 street in that comparison).

Dense models are honest work, not magic. Qwen3.5-27B dense at Q4_K_M decodes at 29–33 tok/s depending on driver and tuning. That’s consistent with the bandwidth math: a ~16.5GB weight sweep through 640 GB/s tops out around 38 tok/s theoretical, so llama.cpp is extracting 75–85% of the card’s ceiling — a sign the RDNA4 software stack has matured. On 7B-class models, a tuned ROCm build hit 98.97 tok/s average on Qwen2.5-Coder-7B Q4_K_M (five-run average, ±1.6% variance).

Prompt processing is the real gap. The same RTX 5090 comparison measured prefill at 2,713 tok/s (R9700, Vulkan, 512-token prompt) vs 7,026 tok/s on the 5090 — and the gap widens to 3.44× at 32K context. If your workload is agentic coding with 50K-token prompts, you will feel this every single turn. Two mitigations are documented: -ub 2048 -b 16384 batching flags recover +29% prefill, and Mesa 25.3.6 brought +48% on MoE prefill — but NVIDIA’s compute lead on prefill is architectural, not a driver bug that’s going away.

Workload (llama.cpp)	R9700	Reference point
Qwen3.5-35B-A3B Q4 decode	127–156 tok/s	RTX 5090: 194 tok/s
Qwen3.5-27B dense Q4 decode	29–33 tok/s	Used RTX 3090 ≈ 40–50 (bandwidth-scaled)
Qwen2.5-Coder-7B Q4 decode	~99 tok/s (tuned ROCm)	RX 9070 XT (same die, Ollama): ~56
Prefill, 512-tok prompt	~2,713 tok/s	RTX 5090: ~7,026 tok/s

The spread between 56 tok/s (stock Ollama on the sibling 9070 XT) and 99 tok/s (tuned llama.cpp ROCm build) on 7B models tells you the one thing that’s still true about AMD: the hardware delivers what the software stack lets it. In 2024 that gap was a chasm; in mid-2026 it’s a tuning session.

ROCm 7.2 native: what “no more HSA_OVERRIDE” actually means

ROCm 7.2 (released January 21, 2026) put gfx1201 — the R9700’s compiled target — on AMD’s official support list for both Linux and Windows. “Native” means precompiled kernels ship in the box, AMD tests the card in CI, and none of the HSA_OVERRIDE_GFX_VERSION spoofing that RDNA2/RDNA3 owners suffered through applies here. We documented that whole workaround era in the AMD GPU not detected fix guide — on this card, you should never need it.

Verify the card enumerates before you touch anything else:

$ rocminfo | grep gfx
  Name:                    gfx1201

If that line appears, llama.cpp built with HIP works immediately — reviewers consistently report first-try compiles on ROCm 7.2:

cmake -B build -DGGML_HIP=ON -DAMDGPU_TARGETS=gfx1201
cmake --build build --config Release -j

The Ollama exception (real error, real fix). Native ROCm support doesn’t automatically flow into apps that bundle their own ROCm libraries. Ollama users on the R9700 have hit a GPU discovery failure where the server stalls for 30 seconds and falls back to CPU, even though rocminfo and rocm-smi see the card fine. The server log looks like this (Ollama issue #13236, still open as of July 2026):

bootstrap discovery took 30.000956172s
failed to finish discovery before timeout
filtering device which didn't fully initialize
total vram = 0 B

The cause is Ollama’s bundled ROCm 6.x libraries lacking gfx1201 kernels — your system ROCm 7.2 is fine, but Ollama isn’t using it. The working fix reported across issues #13236 and #14686 is Ollama’s Vulkan backend:

OLLAMA_VULKAN=1 ollama serve

Set it on the service (systemd drop-in via systemctl edit ollama), not your shell, or it silently does nothing — the same trap as every other Ollama environment variable. Given that Vulkan is also where the community measured the 127+ tok/s MoE numbers, this is less of a consolation prize than it sounds.

If you want the full ROCm-on-Linux walkthrough (repos, groups, kernel modules), our ROCm 7.2 Ubuntu setup guide applies to this card verbatim, and the Windows ROCm state-of-play covers the RDNA4-only Windows situation.

R9700 vs the cards you’re actually cross-shopping

Vs used RTX 3090 (~$1,252 avg, July 2026). The 3090 has 46% more bandwidth (936 vs 640 GB/s) and the CUDA ecosystem, and it’s ~$50 cheaper than the R9700’s MSRP. It wins on dense-model decode and on any tool that assumes NVIDIA. The R9700 counters with 8GB more VRAM, 50W less power, a warranty, and — on MoE models via Vulkan — decode speeds the 3090 can’t reach because the model classes that fit in 32GB don’t fit in 24GB at the same quant. Four years of mining-era wear is also not nothing; we’ve held the “used 3090 is the value king” line since May 2026, and this is the first new card to genuinely pressure it.

Vs used RTX 4090 ($2,150–$2,350). The 4090 is the better GPU — 1,008 GB/s, monstrous prefill, CUDA. It is also ~$900–$1,050 more expensive than an MSRP R9700 for 8GB less VRAM. Per gigabyte of VRAM, you’re paying ~$41/GB for the R9700 vs ~$94/GB for a used 4090. Unless your workload is prefill-dominated (agents, RAG over long documents) or hard-requires CUDA (most Python training stacks still do), the 4090’s premium buys speed you may not notice at chat-length prompts.

Vs RTX 5090 (32GB, $4,000+). Same VRAM capacity, 1.52× the decode, 2.6×+ the prefill, triple the price. The 5090 is the right card for people who bill hourly for their tokens. For everyone else, the R9700’s $1,299 leaves $2,700 in your pocket — enough to add a second R9700 and 64GB of DDR5.

The dual-R9700 path. Two cards = 64GB VRAM for ~$2,600, and llama.cpp splits across them without NVLink drama. Community dual-R9700 testing shows the expected pattern: big gains for capacity and long-context prefill, no improvement to single-stream decode — the same physics we documented for dual RTX 3090 builds. Budget PSU headroom for 600W of GPU and check your PCIe lane topology before buying the second card.

No card at all. If you need 70B+ dense models occasionally rather than daily, renting remains cheaper: an A100 80GB runs $1.39/hr on RunPod, which is ~930 hours of rental before you’ve spent one R9700. The buy-vs-rent math is worked through in our RunPod vs local guide.

Who should buy it

Buy the R9700 if: you run MoE models (the 2026 default — Qwen3.6, Gemma 4 26B-A4B) via llama.cpp or LM Studio on Linux; you want new hardware with a warranty instead of a mined-on 3090; you need 25–32GB models at sane quants; or you’re building a quiet multi-GPU box where blower cards and 300W TDPs stack cleanly.

Skip it if: your tooling is CUDA-locked (fine-tuning with PyTorch is still a rougher road on ROCm — check your exact stack first); your workload is long-prompt agentic coding where the 2.6–3.4× prefill gap bites hardest; or you can find a used 3090 under $1,100 and you only need 24GB. And if you’re wiring any of these cards into Cursor or Cline as a local backend, our sister site covers that at aicoderscope.com.

The bigger story is that this card exists at all. Twelve months ago “32GB of VRAM, new, with warranty, under $1,500” was not a product category — NVIDIA won’t sell it to you (the 5090 is $4,000+, the RTX PRO 6000 is $12,000+), and NVIDIA has no consumer refresh coming in 2026. AMD found the gap and, for once, shipped the software to match.

FAQ

Is the R9700 GDDR7? No — 32GB of GDDR6 on a 256-bit bus at 20 Gbps, for 640 GB/s. Several aggregator sites list GDDR7; AMD’s datasheet says GDDR6.

Does it work with Ollama? Yes, with one flag. Ollama’s bundled ROCm libraries don’t include gfx1201 kernels, so ROCm discovery can time out and fall back to CPU (issue #13236). Run with OLLAMA_VULKAN=1 set on the service and it uses both the GPU and, in multi-card rigs, all GPUs.

Can it run a 70B model? Not alone — 70B Q4_K_M needs ~42.5GB. One R9700 gets partial offload speeds; two R9700s (64GB, ~$2,600) run it fully on-GPU.

What’s the gfx target for building llama.cpp? gfx1201. Build with -DGGML_HIP=ON -DAMDGPU_TARGETS=gfx1201 on ROCm 7.2+, or skip the build entirely and use the Vulkan backend, which needs no ROCm install.

Is it faster than a used RTX 3090? Depends on the model. Dense models: no — the 3090’s 936 GB/s wins decode. MoE models that need more than 24GB, or anything at Q6/Q8 in the 20–30B class: the R9700 runs them where the 3090 can’t, which is a different kind of faster.

Recommended Gear

AMD Radeon AI PRO R9700 32GB — the card this guide is about; check MSRP ($1,299) before paying resale markups
Corsair Vengeance 64GB DDR5 — system RAM headroom for model loading and CPU-offload experiments

Sources

Last updated July 23, 2026. Prices and specs change; verify current rates before purchasing.

Was this article helpful?