Best Local LLM on Intel Arc B580/B570 — Battlemage Tested

Twelve gigabytes of VRAM for $249 looks unbeatable on paper. After six months of Battlemage drivers maturing, here is what actually runs well — and what to skip.

By Mohamed Meguedmi · 11 min read

Why Battlemage finally matters for local inference

The Intel Arc B580 launched in December 2024 at $249 with 12 GB of GDDR6 on a 192-bit bus, delivering 456 GB/s of memory bandwidth. The cheaper B570 followed in January 2025 at $219 with 10 GB on a 160-bit bus (380 GB/s). Both use Xe2 ("Battlemage") with 20 and 18 Xe cores respectively, and both include the XMX matrix engines that make INT8 and INT4 inference fast.

For eighteen months Arc was a punchline in local-LLM circles — drivers crashed, llama.cpp's SYCL backend was half-broken, and PyTorch XPU was experimental. That changed in late 2025. The Linux Intel Compute Runtime 25.x brought stable OpenCL and Level Zero, IPEX-LLM 2.3 shipped Battlemage-specific kernels, and vLLM merged the XPU backend. As of May 2026 the stack is genuinely usable.

The question is no longer "does it work?" but "which model and which runtime?" That is what we tested. Our full methodology is documented at /methodology/; raw numbers are mirrored to the BestLLMfor public API (CC BY 4.0).

Hardware specs at a glance

Two things jump out. First, the B580 has more raw bandwidth than the RTX 3060 and the RTX 4060 Ti 16 GB — and bandwidth is what dictates token-generation speed for memory-bound decoder transformers. Second, the older A770 16 GB still has the highest bandwidth and the most VRAM in this price band; if you can find one new, it is the cheapest path to running 14B at FP8.

Benchmark results — 5 models, 3 runtimes

All tests run on Ubuntu 24.04, kernel 6.11.0, Intel Compute Runtime 25.13, IPEX-LLM 2.3.0, llama.cpp build b5042 with SYCL, vLLM 0.7.3 with XPU. Prompt: 512 tokens, generation: 256 tokens, batch size 1, greedy decoding. Numbers are the median of 5 runs, ±2%.

The headline: the B580 with IPEX-LLM is within 5-7% of an RTX 3060 on 8B models and actually beats it on 14B, because the higher bandwidth matters more when the weights barely fit. The B570 is a different story — Qwen3 14B Q4_K_M does not fit in 10 GB once you account for KV cache, leaving you stuck on the 7B-9B tier.

Note how badly upstream llama.cpp SYCL underperforms. Until that backend catches up (the tracking issues show active work), IPEX-LLM is the right default on Battlemage.

Which model should you actually run?

Best all-rounder: Qwen3 14B Q4_K_M

If you bought a B580, this is the model to install first. It pushes the card to ~10.8 GB used, leaves 1 GB for a 4K context KV cache, and produces noticeably better reasoning than any 8B model. The official Qwen3 14B card on HuggingFace documents the chat template and tool-calling format. Use the bartowski GGUF quants for direct Ollama or IPEX-LLM loading.

Best coding assistant: DeepSeek-R1-Distill-Qwen 14B

For "write me a Python function" workloads, the R1-distilled 14B beats both stock Qwen3 14B and Llama 3.1 8B on HumanEval+ at roughly the same memory footprint. Throughput at 27 tok/s is fast enough that a copilot integration feels live, not laggy.

Best lightweight (B570 owners): Llama 3.1 8B Q4_K_M

The B570's 10 GB ceiling forces you down to 8B for any practical context window. Llama 3.1 8B Instruct at Q4_K_M leaves room for a 16K context and hits 36 tok/s. Qwen3 8B is slightly slower but better at non-English tasks — see the French-focused testing at quelllm.fr for that comparison.

Skip on a single B580

Anything above 14B at Q4. Qwen3-Coder 32B, Llama 3.3 70B, and Mistral Large will not fit. You can run 32B by adding a second B580 with tensor parallel via vLLM XPU — see below — but a single card is firmly in 7B-14B territory.

Recommended software stack

sudo apt update
sudo apt install -y intel-opencl-icd intel-level-zero-gpu level-zero \
  intel-media-va-driver-non-free libmfx1 libmfxgen1 libvpl2
# Verify
clinfo | grep -i "Arc"
sudo dmesg | grep i915

conda create -n ipex python=3.11 -y
conda activate ipex
pip install --pre --upgrade ipex-llm[xpu_2.6] \
  --extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
# Sanity check
python -c "import torch; import intel_extension_for_pytorch as ipex; \
  print(torch.xpu.is_available(), torch.xpu.get_device_name(0))"

# IPEX-LLM ships a drop-in Ollama replacement
pip install --pre --upgrade ipex-llm[cpp]
init-ollama   # creates ./ollama symlinks
./ollama serve &
./ollama pull qwen3:14b
./ollama run qwen3:14b

pip install vllm  # 0.7.3+ has XPU support
vllm serve Qwen/Qwen3-14B-AWQ \
  --device xpu --dtype float16 --max-model-len 8192
# Two-GPU tensor parallel for 32B models
vllm serve Qwen/Qwen3-Coder-32B-Instruct-AWQ \
  --device xpu --tensor-parallel-size 2 --max-model-len 4096

Two-B580 builds — the real value play

Two B580s cost ~$500 and give you 24 GB of pooled VRAM at 912 GB/s aggregate bandwidth, drawing 380 W under load. The equivalent NVIDIA path is a single RTX 4090 (~$1,800 used) or two RTX 3060s (~$560, 24 GB, 720 GB/s). On a pure $/GB-bandwidth basis the dual-B580 path wins by ~30%.

The catch is tensor parallel maturity. vLLM XPU works for AWQ and GPTQ checkpoints; GGUF tensor parallel on Battlemage is still experimental in llama.cpp. If your workflow centers on GGUF you are better off with a single card. If you can use AWQ, two B580s are the cheapest way under $600 to run Qwen3-Coder 32B locally.

Cost-per-million-tokens math, including idle power, is in our cost calculator. For a 14B-class workload running 4 hours/day at $0.18/kWh, a single B580 amortizes against a Claude Haiku API spend of roughly $11/month after the first six months.

B580 vs B570 vs A770 — buying verdict

What is still rough

• Flash Attention 2 is not on XPU yet. Long-context (>16K) performance is noticeably worse than CUDA because attention falls back to a slower kernel.
• bitsandbytes 4-bit has no XPU backend. AWQ and GPTQ work; bnb-style on-the-fly quantization does not.
• Windows performance trails Linux by 10-15% on identical drivers as of May 2026. If you must use Windows, install IPEX-LLM inside WSL2 — but expect another 8% loss vs native Linux.
• Training and fine-tuning work via PyTorch XPU but ecosystem support (Axolotl, Unsloth) lags. Inference is the right primary use case.

Integrating Battlemage into agent workflows

If you are wiring a local Battlemage box into Claude Code, Cline, or Continue.dev as a fallback model, the path of least resistance is the IPEX-LLM Ollama fork on port 11434 — every IDE plugin already speaks the Ollama API. For MCP-based routing across multiple local providers, the open-source quelllm-mcp server exposes Battlemage endpoints alongside other local backends and handles per-model routing rules. More background on our testing approach is at /about/.

Conclusion — should you buy a B580 for local LLMs?

Yes, with one condition: you are comfortable on Linux and you accept that the model ceiling is ~14B at Q4. Under those constraints the B580 is the best $249 you can spend on local inference in 2026. It beats the RTX 3060 12 GB on 14B-class throughput, costs $30 less, and the IPEX-LLM stack is mature enough that day-to-day use is uneventful.

The B570 is harder to recommend. Saving $30 to permanently lose the 14B tier is a false economy — pay the difference. And if you can stretch to $500, two B580s with vLLM XPU is genuinely the cheapest local path to running 32B coders.