Arc Pro B70

An Arc Pro B70 runs 28 of the 34 open models tracked here at Q4_K_M with 8k context, computed on 16 October 2026. The largest is Qwen3.6 35B-A3B (MoE), needing 22.4 GB and generating at most 245 tokens per second.

Updated

Memory
32 GB VRAM
Bandwidth
608 GB/s
Board power
230 W
Released
2026
Availability
Workstation card
What it runs
28 of 34 models
At Q4_K_M with 8k context. The largest it holds is Qwen3.6 35B-A3B (MoE): 22.4 GB, at most 245 tokens per second.
Computed 16 October 2026
Best model to run
Muse Glimmer 30B
18.7 GB of 32 GB, about 25 tokens per second: usable, a little slow. Picked as the biggest class of model that fits with room to spare and answers at 25 tokens per second or faster, then the newest release in it.
Computed 16 October 2026

Open the Arc Pro B70 in the LLM checker

What an Arc Pro B70 runs, model by model

Arc Pro B70 (32 GB) addresses 32 GB at 608 GB/s. Every model below is at Q4_K_M with 8k of context, the setting most people actually use. Once the 5% safety margin comes off, the card has 30.4 GB to spend: memory decides what loads, bandwidth how fast it answers. Both are estimates from stated formulas, and the VRAM calculator shows the working.

On this card a model fits at or under 30.4 GB, and above 27.2 GB it is tight: it loads, but there is little left for the conversation, and a desktop on the same 32 GB can push it over. Tokens per second are single-stream estimates from memory bandwidth; ≤ marks a ceiling real runtimes fall well below.

Computed 16 October 2026

The model to actually run on it

Muse Glimmer 30B is the best use of this card: 18.7 GB of the 32 GB available, an estimated 25 tokens per second, usable, a little slow, and 131,072 tokens of context still available.

How this is chosen, since no benchmark is quoted: models are compared by size, a mixture-of-experts model counting at the geometric mean of its total and active parameters (a rule of thumb, not a measurement). The pick is the biggest class that fits with memory to spare and answers at 25 tokens per second or better, and within that class the most recent general-purpose release; coding and reasoning specialists are listed above but not recommended by default.

Qwen3.6 35B-A3B (MoE) is the largest model the card will hold, at 22.4 GB, with room for 131,072 tokens of context. It is a mixture-of-experts model reading only 3B parameters per token, so it is the faster of the two at an estimated 245 tokens per second; what it gives up is the depth of a dense model that reads all of its weights for every token.

If quality matters more than parameter count, Mistral Small 3.1 24B fits at Q8_0 in about 28.3 GB. Q8 is near-lossless; a smaller model at Q8 often beats a larger one squeezed into Q3.

How much context actually fits

Model size is the question people ask; context is the one that bites. The KV cache grows linearly with the conversation, so a model that loads comfortably can still run out of memory halfway through a long document. On 32 GB, the context you get is whatever the weights leave behind, which is why two cards that run the same model can feel completely different in use. These are the largest contexts this card holds, at Q4_K_M weights.

ModelMax context, FP16 KVWith Q8 KV cache
Muse Glimmer 30B 131,072 tokens 131,072 tokens
Qwen3 32B 37,888 tokens 40,960 tokens · model limit
Gemma 4 31B 123,904 tokens 131,072 tokens
Granite 4.2 30B 46,080 tokens 93,184 tokens

Quantising the KV cache to Q8 roughly doubles what you can hold, at a quality cost most people never notice: Gemma 4 31B on this card goes from 123,904 to 131,072 tokens. Capped at 128k tokens, or at the model's own native window where that is smaller, marked "model limit": free memory beyond that point buys nothing. Rows that hold far more context than their size suggests are hybrid, sliding-window or latent-attention models, which cache only a fraction of what a standard transformer does; each model page shows the working.

Computed 16 October 2026

Where this card stops

The first model out of reach is Llama 3.3 70B: about 45.8 GB at Q4_K_M and 8k context, against 32 GB of usable memory. Dropping to Q3_K_M would need about 37.7 GB, which still does not fit. Offloading the remainder to system RAM works and is ten to fifty times slower; it is a way to see a model run, not a way to use one.

Buy or rent

Worth it when you need 32 GB on one card at modest power and your tools run on Intel, typically llama.cpp, or vLLM under LLM Scaler on Linux. If you need speed, an RTX 5090 reads 32 GB nearly three times as fast and runs CUDA, at 575 W. For occasional 32 GB work, renting by the hour costs less than owning.

Workstation cards are sold on quotes rather than shelf prices, so there is no single number to publish. Put the figure you are actually looking at, with your electricity rate and your real monthly hours, into the build vs rent calculator, which already knows this card draws 230 W under load. It returns the month owning becomes cheaper, or tells you it never does. Hours per month decides it far more often than the price does.

The honest take

Intel's 32 GB workstation card: RTX 5090 capacity at 608 GB/s, on Intel's software.

It holds what an RTX 5090 holds, 32 GB, with ECC, and reads it at 608 GB/s: a third more than an Arc Pro B60, a little under a Radeon AI PRO R9700, and about a third of a 5090. The software is the open question. llama.cpp supports it through SYCL and Vulkan, Ollama through Vulkan, and Intel's LLM Scaler packages vLLM for it on Linux, but CUDA-only tools do not run.

What it is good at

  • 32 GB with ECC on one card, at 230 W for Intel's own design.
  • Intel's LLM Scaler added the B70 in 2026 and packages vLLM with tensor parallelism across cards.
  • Pro drivers with ISV certifications, and Intel says its consumer game drivers can be installed instead.

What it is not

  • 608 GB/s is about a third of an RTX 5090: dense models that need the 32 GB generate slowly.
  • Intel's AI software is younger than CUDA or ROCm: IPEX-LLM is archived, and Intel's own vLLM route runs in containers on Linux.
  • No CUDA.

The thing people get wrong: There is no single power figure: Intel rates its own card at 230 W and lists 160 to 290 W for partner designs. The 32 GB and the 608 GB/s stay the same, but clocks, noise and the power supply you need do not, so check the specific board.

Compared with the alternatives

  • Radeon AI PRO R9700: 32 GB · 640 GB/s · best fit Muse Glimmer 30B at ~26 tok/s. AMD's 32 GB workstation card: RX 9070 XT bandwidth with twice the memory, at 300 W.
  • Arc Pro B60: 24 GB · 456 GB/s · best fit Gemma 4 12B at ~46 tok/s. Intel's 24 GB workstation card: the B580's bandwidth with twice the memory.
  • RTX 5090: 32 GB · 1,792 GB/s · best fit Muse Glimmer 30B at ~73 tok/s. The first consumer card whose memory bandwidth changes what is comfortable.

All 39 cards are compared side by side on the GPU index, and the same numbers from the model's point of view are on each model fit table. To check one specific pairing rather than read a table, use the can-I-run-it checker.

Questions

Can an Arc Pro B70 run a 70B model?
Not at Q4_K_M in one card. Llama 3.3 70B needs about 45.8 GB at 8k context and this card can address 32 GB. Your options are a smaller model, a harsher quantisation with very little context, splitting across two cards, or renting a larger one for the hours you need it.
What is the best model to run on an Arc Pro B70?
Muse Glimmer 30B. At Q4_K_M and 8k context it needs about 18.7 GB of the 32 GB available and generates an estimated 25 tokens per second, which is usable, a little slow. If quality matters more than size, Mistral Small 3.1 24B fits at Q8 in about 28.3 GB.
How many tokens per second does an Arc Pro B70 generate?
It depends entirely on the size of the model, because generating a token means reading every active weight out of memory. At 608 GB/s and 70% efficiency, this card produces an estimated 92 tokens per second on an 8B model at Q4, and about 245 on the largest model it holds, Qwen3.6 35B-A3B (MoE). Reading speed is roughly 5 to 8 words per second, so anything above 25 feels immediate. Treat 92 as a ceiling on 608 GB/s rather than a measurement; the higher a figure, the further real runtimes fall below it.
Is 32 GB enough for running LLMs locally?
It runs 28 of the 34 models tracked here at Q4_K_M with 8k of context, up to 36B parameters. The honest test is not the model list but the context: Muse Glimmer 30B on this card holds about 131,072 tokens before memory runs out.
Arc Pro B70 or Radeon AI PRO R9700 for local models?
Both address about the same memory, so they run the same models. On speed, the Radeon AI PRO R9700 is faster: 640 GB/s against 608 GB/s, and bandwidth is what sets chat speed.
Arc Pro B70 or RTX 5090 for local LLMs?
Both hold 32 GB, so the same models fit. The 5090 reads memory at 1,792 GB/s against 608 GB/s, nearly three times as fast, and runs CUDA, which most tools support first. The B70 draws 230 W in Intel's own card against 575 W and has ECC memory. For speed and software, the 5090; for 32 GB at low power, the B70.
Does Ollama support the Intel Arc Pro B70?
Through its Vulkan backend, which Ollama turns on by default on Windows and Linux; its hardware page does not list Intel cards by name. Intel's own route for this card is LLM Scaler, which packages vLLM in containers for the Arc Pro B60 and B70, and llama.cpp supports Intel GPUs through SYCL.
  • Memory: weights (parameters × bytes per parameter) + KV cache (2 × layers × KV heads × head dim × context × bytes for a standard transformer; sliding-window, hybrid and latent-attention models counted as they actually cache) + 0.5 GB runtime + 4% of weights. Full derivation in the VRAM calculator.
  • Speed: 70% × bandwidth ÷ active weight bytes, single stream, no batching, prompt processing excluded. A ceiling, not a measurement: the 8 of 28 figures marked ≤ are where real runtimes fall furthest below the number, because so few weights are read per token. See the tokens-per-second estimator.
  • Card specification (manufacturer figures): 32 GB, 608 GB/s, 230 W; see Intel's own page for this card.
  • Model architecture values come from each model's published config; the self-hosted LLM guide explains what each one changes.