A 32GB GPU for a Third of the Price? Intel’s B70 for Local AI

Local AI has made tremendous strides over the last few months and I’ve been looking at the most affordable ways to implement it, like using an old Mac, or pairing two GPUs together to maximize memory. In my latest video, I sought out the lowest cost 32GB GPU solution I could find and landed on the Intel B70 (compensated affiliate link).

See it in action here!

While prices have fluctuated recently—this GPU cost a few hundred dollars less just a few weeks ago—it remains a practical alternative to higher-end Nvidia options for those operating on a more modest budget. It won’t be as fast but it’s fast enough for most workflows.

The primary advantage of the 32-gigabyte capacity is the ability to run dense models, such as the 27-billion-parameter Qwen 3.8, entirely on the GPU. This prevents the system from having to offload data to slower system RAM or the CPU. In my testing, the setup generates approximately 25 tokens per second, rarely dropping below 20 even when the context window is heavily loaded. For example, I used the model to summarize a complex appeals court ruling regarding DJI litigation and the result was every bit as good as what you might get from ChatGPT or Gemini. The system processed the legal text and generated a structured summary and a chart without relying on cloud resources.

The hardware configuration I demoed involves an Oculink connection to a MinisForum Mini PC equipped with an AMD Strix processor. While a mini PC of this caliber might be more power than necessary when the GPU is doing the heavy lifting, it served as a convenient platform for the project. The operating system is Ubuntu 26.04, which has proven stable for these applications.

Normally I’d do a how-to in a video like this to get things working. But these days, it’s easier to just let AI do most of the heavy lifting especially given how frequently things are changing in this space. For this project I had ChatGPT’s CODEX command line interface verify the hardware install and find the appropriate drivers. This approach has allowed me to resolve configuration issues that might otherwise be time-consuming, resulting in a more efficient setup.

Practical applications for this local setup extend into coding and data management. I developed a tool called “The Gadget Tracker,” which filters RSS feeds from technology publications. The Qwen model analyzes article text to determine if they pertain to hardware gadgets rather than general industry news or software algorithms. Valid entries are then stored in a local SQLite database for review in a to-do list format. I also demoed Qwen 2.8 modifying the application’s user interface, adding social media images to the display cards and adjusting UI elements. The model’s reasoning process is perhaps a little more methodical than a frontier model with more resources; it often takes time to contemplate its plan before executing code, which helps minimize errors in the final output.

Another test involved extracting data that is difficult to capture through traditional copy-and-paste methods. I tasked the model with gathering names and email addresses for the New York City Council from their official website. Because the emails were embedded within the site’s source code rather than displayed directly on the page, a simple scrape wouldn’t work. The local model used a curl command to pull the HTML, identified the relevant strings, and formatted the data into a CSV file in under two minutes.

There are trade-offs to this local approach, particularly regarding power and acoustics. The GPU fan is audible even when the system is idle, and the card consumes about 55 watts just sitting with a model loaded. Under a full processing load, that consumption rises to over 320 watts.

Despite the power demands, the ability to process 96,000 tokens of context locally provides a level of privacy and unlimited usage that cloud services cannot match. The technology in this space is moving quickly, with software updates frequently unlocking better performance from existing hardware. This specific configuration has reached a point where it handles the majority of the tasks I previously delegated to proprietary models, proving that local hardware is increasingly capable of meeting professional demands. My focus now shifts to optimizing the power draw while continuing to test how these dense models handle more complex, long-term projects.