Arc B60 vs RX 7900 XT: a real comparison, not a chart fight

The most common GPU comparison online is two bars in a chart: Card A is faster than Card B, buy Card A. The problem is that those comparisons usually change two variables at once — the card and the model and the quant — and report a single number that mashes all three effects together. We did exactly that in our first pass and got the story wrong. This post is the corrected version: a clean 2×2 that separates the GPU effect from the architecture effect.

The setup

We ran two models on two GPUs, using byte-identical artifacts (verified by sha256 hash across machines) and identical llama-bench settings (-p 512 -n 256 -ngl 99 -r 3):

• Models: Llama-3.1-8B-Instruct (dense, 8.03B active params) and LFM2.5-8B-A1B (MoE, ~1.7B active params). Same parameter class (8B total), opposite architectures.
• GPUs: Intel Arc Pro B60 (Battlemage, 24GB VRAM, ~$400) and AMD Radeon RX 7900 XT (gfx1100, 20GB VRAM, ~$700).
• Backends: Vulkan (Mesa ANV) on the Arc B60; ROCm 7.2.2 (HIP) on the RX 7900 XT.

The full data lives in bm-007 (LFM2.5-8B on both cards) and bm-008 (Llama-3.1-8B on both cards).

The 2×2

Generation speed (tg256, tokens/second):

	Arc B60 (Vulkan)	RX 7900 XT (ROCm)	RX / Arc
Llama-3.1-8B (dense)	27.01	105.22	3.90×
LFM2.5-8B (MoE)	68.79	269.01	3.91×
MoE / dense	2.55×	2.56×

Read it two ways: across rows tells you the GPU effect; down columns tells you the architecture effect.

Finding 1: the GPU gap is ~3.9×, and it's consistent

The RX 7900 XT is roughly 3.9× faster than the Arc B60 on generation — and critically, that ratio holds across both model architectures (3.90× on dense, 3.91× on MoE). That consistency is what tells you the gap is really the GPU driving it, not noise or a model-specific quirk.

This isn't shocking — the RX 7900 XT costs ~75% more, has higher memory bandwidth, and ROCm is a more mature stack than Mesa Vulkan on Battlemage. But the consistency is the useful part: it means the B60's deficit isn't a Vulkan-on-dense problem or an MoE-on-AMD problem. It's a card-for-card difference.

Finding 2: the architecture gap is ~2.5×, and it's also consistent

MoE (Mixture-of-Experts) is roughly 2.5× faster than dense at the 8B class — and that ratio also holds across both GPUs (2.55× on the Arc, 2.56× on the RX 7900 XT). Same consistency logic: the architecture is driving this, not the GPU.

The "why" is mechanical. LFM2.5-8B-A1B has ~8.5B total parameters but only activates ~1.7B per token — the router picks a small subset of experts per forward pass. Llama-3.1-8B dense activates all 8B every token. Less work per token means more tokens per second, at the cost of per-token quality (you're using fewer of the model's parameters for any given output).

What we got wrong the first time

Our first version of this comparison said "~10× speed gap, dense vs MoE." That number was real — but it was GPU × architecture compounded (3.9 × 2.55 ≈ 10). We'd compared Llama-on-Arc against LFM-on-RX, changed two variables at once, and reported the product as if it were one effect.

The honest version separates them: ~3.9× from the GPU, ~2.5× from the architecture. Each is useful on its own. Multiplied together they're misleading.

We logged a correction on both records and kept the original numbers (they were measured correctly — it was the framing that was off).

So which card should you buy?

Depends on the question you're actually asking. A few honest reads from this data:

If you want maximum single-stream speed and your budget allows ~$700: the RX 7900 XT wins clearly. 269 tok/s on an 8B MoE is genuinely fast — usable for real-time agent loops, voice assistants, multi-turn tool use. ROCm is mature on gfx1100 and the card has the bandwidth to back it up.

If you're budget-constrained at ~$400 and OK with "usable, not fast": the Arc B60 at 68.79 tok/s (MoE) or 27 tok/s (dense) is a real workstation card. It's not going to win races, but for one developer doing real work it's enough. The 24GB VRAM is the B60's actual selling point — that's more memory per dollar than the RX 7900 XT's 20GB, and it matters more than raw tok/s for fitting larger models.

If you're choosing a backend for multi-agent serving: neither of these numbers is the right one to look at. Single-stream tok/s ≠ serving throughput. See our OpenVINO post — OVMS's continuous batching changes the math on the B60 specifically.

The caveats we owe you

• Backends differ by design. ROCm on the RX 7900 XT, Vulkan on the Arc B60. Those are the correct backends per platform (ROCm for AMD gfx1100, Vulkan or OpenVINO for Battlemage), but it means this is GPU+backend vs GPU+backend, not a pure silicon test.
• Same model bytes, verified. We pulled each model onto both machines and confirmed sha256 hashes matched before running — so the comparison isn't muddled by different quantization artifacts.
• Short context only. llama-bench's default context (~2K). Long-context behavior (64K+) changes the picture, especially VRAM-limited — that's a follow-up.
• Two models isn't every model. The 8B class is a reasonable proxy but not universal. A 30B or 70B comparison would stress VRAM and bandwidth differently.

The takeaway

A good comparison isolates one variable at a time. The 2×2 above lets you read the GPU effect and the architecture effect independently, and the consistency of both ratios (3.9× either way, 2.5× either way) is what makes the findings trustworthy. If the ratios had bounced around — say 4× on one model and 2× on the other — we couldn't say "the GPU is 3.9× faster" with a straight face. They didn't, so we can.

The full records — every flag, every limitation, every raw number — are in bm-007 and bm-008. For the broader mid-2026 Arc picture — a year of Battlemage in the lab, drivers, backends, where the B580/B60 actually fit — see Battlemage one year in. And if you want to check whether a specific model fits your target card's VRAM, Model Fit does the math.