Intel Arc B580 Shows Big AI Speed Gains in 125B Model Test With XeStrata
Intel’s Arc B580 graphics card is gaining attention after a new local AI inference test showed a major performance jump when paired with optimized software. In the test, the 12GB Intel Arc B580 delivered 31.1 tokens per second while running a 125-billion-parameter language model through XeStrata. That is nearly three times faster than the 10.9 tokens per second recorded with Strata on the same system.
The result is notable because a graphics card with 12GB of VRAM is not usually the first hardware people think of when discussing massive AI models. Large language models with hundreds of billions of parameters typically demand substantial memory resources. However, this test highlights an important point for anyone interested in running AI locally: the software stack can have a huge impact on real-world performance.
The benchmark used an ASRock Intel Arc B580 Challenger 12GB OC graphics card, an Intel Core Ultra 5 250KF Plus processor, and 64GB of DDR5 system memory. The operating system was Ubuntu 26.04 LTS. The model used was Qwen3.8-Flash-Next, configured with IQ3_S quantization, a 64K-token context, and an 8-bit KV cache.
Those configuration details matter. Quantization reduces the amount of memory required to run a model, while context length and cache settings can significantly affect speed and system memory usage. In this case, the 12GB GPU was not working alone. The system also relied heavily on main memory, which is why the 64GB RAM configuration was essential.
The test does not mean that a full 125B model can fit entirely inside 12GB of graphics memory. Instead, tools such as Strata and XeStrata are designed to combine GPU acceleration with system RAM, allowing very large models to run on more accessible consumer hardware. According to setup information for this type of configuration, the selected quantization level can require around 50GB of system memory. That makes the 64GB RAM setup a key part of the result.
This is an important distinction for users building a budget-friendly local AI system. VRAM is still important, but it is not the only factor. System RAM, inference engine support, drivers, model format, and software optimization can all dramatically affect the experience.
The biggest difference in this test came from switching between two inference engines. Strata 0.2.1 achieved 10.9 tokens per second, while XeStrata reached 31.1 tokens per second using the same model and hardware configuration. XeStrata is derived from Strata but includes additional optimizations for supported GPU architectures.
XeStrata’s documentation points to improvements for Intel GPU execution paths, including better use of Intel’s XMX matrix acceleration hardware for certain operations. The Intel Arc B580 includes this acceleration hardware, which can help with AI-related workloads when properly supported by software.
However, the test does not prove that one single optimization caused the entire speed increase. The result should be viewed as a comparison between two different software configurations running on identical hardware. It shows that inference software can make a massive difference, but it does not isolate one feature as the sole reason for the performance gain.
It is also important to understand what the benchmark measured. The reported figure focuses on text-generation throughput, measured in tokens per second. It does not necessarily mean similar gains will appear in prompt processing, response latency, model accuracy, coding agents, multimodal AI tasks, or every other local AI workload.
Even so, the improvement from 10.9 to 31.1 tokens per second is substantial. For users interacting with a local language model, faster token generation can make responses feel much smoother and more practical. A near-threefold increase can be the difference between a sluggish experiment and a usable local AI setup.
Still, the Intel Arc B580 does not suddenly erase the hardware demands of large AI models. Running a 125-billion-parameter model remains a heavy task. The test system needed 64GB of RAM, and more demanding workloads may still benefit from stronger GPUs, larger VRAM capacity, faster memory, and better support for long context windows.
Agent-based AI workflows, in particular, can be much more demanding than simple text generation. These workloads may involve extended context, repeated tool calls, multiple reasoning steps, and larger memory requirements. In those scenarios, a 12GB GPU may still feel limited, even with strong software optimization.
There is also a software version factor to consider. The XeStrata package used in the test was not the newest release available at the time of reporting. Later updates introduced additional changes, and the project has also documented Intel driver-related performance issues affecting some Linux configurations. As a result, the 31.1 tokens-per-second figure should not be treated as a universal benchmark for every XeStrata version, driver setup, or Linux installation.
The broader takeaway is more useful than the raw number. This test shows that local AI performance is not determined by GPU specifications alone. Two inference engines running the same large language model on the same Intel Arc B580 system produced dramatically different results.
For anyone exploring local AI inference, the lesson is clear: choose the right software as carefully as you choose the hardware. VRAM, system RAM, processor performance, drivers, quantization settings, and inference engine optimizations all work together. A well-optimized setup can unlock far better performance from affordable hardware than expected.
The Intel Arc B580 may not be a high-end AI accelerator, but this result shows that with the right software, it can deliver surprisingly strong local language model performance. For budget-conscious users interested in experimenting with large AI models at home, the combination of a 12GB Intel Arc GPU, enough system memory, and optimized inference tools could be far more capable than it first appears.
