Intel Arc B580 runs AI 125B model nearly 3x faster with XeStrata in new test

A graphics card with 12GB of VRAM might not seem like an obvious choice for running a 125 billion parameter AI model. However, a new test involving Intel’s Arc B580 suggests that the software that manages the workload can make a substantial difference in performance.

In tests published on October 26, Japanese tech publication PC Watch recorded 31.1 tokens per second using the open-source XeStrata inference engine. The same system achieved 10.9 tokens per second with Strata, the project from which XeStrata was derived.

This equates to approximately 2.85 times the speed of the original generation, or an improvement of approximately 185%, without changing the graphics card.

The 12GB GPU is only part of the equation

The test used an ASRock Intel Arc B580 Challenger OC 12GB along with an Intel Core Ultra 5 250KF Plus processor and 64GB of DDR5 memory. Ubuntu 26.04 LTS was the operating system.

The model was Qwen3.8-Flash-Next, configured with IQ3_S quantization, a 64K token context, and an 8-bit KV cache. These details are significant because quantization, context length, and memory allocation can affect inference performance.

Despite the designation of 125 billion model parameters, the test does not prove that the entire model can accommodate 12 GB of VRAM. Strata and XeStrata are designed to use system memory in conjunction with GPU acceleration, allowing substantially larger models to run on hardware with relatively limited graphics memory.

The particular quantization selected for this test requires approximately 50 GB of system RAM according to Strata’s configuration information. As a result, the 64GB memory configuration is an essential part of the result, rather than a peripheral detail.

For those considering local AI inference on a budget, this distinction is probably more useful than GPU specs alone.

What changed between the two results?

The comparison involved Strata 0.2.1 and XeStrata, a derivative that incorporates additional optimizations for supported GPU architectures.

PC Watch installed XeStrata using the Ubuntu 0.1.43-2 package, corresponding to the xe0.1.43.1 version of the project. Both engines were tested using the same model and configuration.

The XeStrata release documentation describes improvements to Intel GPU execution paths, including the use of XMX matrix hardware for certain operations. However, the comparison published by PC Watch does not establish how much of the measured speed difference comes from individual optimization.

The result should therefore be understood as a comparison between two software configurations on the same computer, not as proof that one specific technique is responsible for the entire gain.

It also affects text generation throughput. It does not establish equivalent improvements in timely processing, response latency, model accuracy, or other AI workloads.

Faster inference doesn’t eliminate hardware limitations

At 31.1 tokens per second, the XeStrata configuration produced text at nearly three times the rate seen with Strata. This is a significant difference in the reported test, especially since both results come from the same 12GB graphics card.

However, managing a large model remains challenging. The test required 64GB of system memory, and the reviewer deemed the Arc B580 insufficient for heavier agent-based workloads, where higher GPU performance, more VRAM, and longer context windows may be preferable.

There is also an important distinction based on the software version. The XeStrata package tested by PC Watch is no longer the latest one available. The October 24 project release introduced additional changes and documented performance issues related to Intel drivers affecting some Linux configurations.

As a result, the 31.1 token result should not be treated as a benchmark for every XeStrata version or driver combination.

What’s more interesting isn’t that a 12GB GPU somehow exceeded the memory requirements of a 125B model. The fact is that two inference engines running the same model on identical hardware resulted in significantly different build speeds.

For users experimenting with large language models locally, this makes software choice an important consideration along with VRAM, system memory, and the graphics card itself.