The prevailing wisdom in AI circles says you need thousands of dollars in GPU hardware to run large language models locally. A blog post from this week offers a counterpoint: a refurbished mini PC costing $537, running open-source software, produces the same answers as cloud services. It just takes a few seconds longer.
The setup is straightforward. A Minisforum UM790 Pro, purchased refurbished with 64GB of RAM and a 1TB NVMe drive, runs Ollama and Open WebUI on Linux. The machine's AMD Ryzen 9 7940HS processor handles inference without a discrete GPU. The author stripped the WiFi and Bluetooth card, enabled OPAL drive encryption, and initially ran OpenBSD before switching to Linux for better model compatibility.
What "Good Enough" Actually Looks Like
Local inference on CPU-only hardware delivers between 5 and 20 tokens per second, depending on the model and prompt complexity. For comparison, a dedicated GPU typically pushes 50 to 100 tokens per second. The gap is real but less dramatic than it sounds in practice.
The author tested queries against duck.ai and various Anthropic Claude models, comparing response quality and speed. Cloud services returned answers nearly instantly. The local machine took 1.2 seconds for a simple query, processing 73.77 prompt tokens per second and generating 13.8 response tokens per second. A more complex question took 3 seconds, with the response arriving at 12.96 tokens per second.
The critical observation: the answers were identical. The local LLM produced the same output as the cloud-hosted version of the same model. The only difference was speed.
For many use cases, a 3-second delay is irrelevant. An agent processing a batch of documents, a developer running code generation in a loop, or anyone working with sensitive data that can't leave their machine doesn't need instant responses. They need correct responses, delivered privately.
The Hardware Question
The Minisforum UM790 Pro is a compact desktop, roughly the size of a thick paperback book. It ships with the AMD Ryzen 9 7940HS, a mobile processor with eight cores and integrated Radeon 780M graphics. The 64GB of RAM is the key spec for LLM work: running a 7-billion-parameter model in quantized form requires roughly 4 to 8GB, while larger 13B models need 16 to 24GB. With 64GB available, the machine can handle most open-weight models without swapping to disk.
The refurbishment price of $537 puts this in a different category than the $3,000 to $10,000 builds that dominate local LLM discussions. The author didn't need custom cooling solutions, expensive power supplies, or multiple GPUs. A single mini PC with enough RAM handled the workload.
The decision to remove the WiFi and Bluetooth card reflects the privacy-first approach. Running models locally means keeping data off the network entirely. An air-gapped machine with encrypted storage and no wireless radios is about as private as a computing device can get.
OpenBSD and the NPU Question
The initial choice of OpenBSD is notable. Most local LLM guides assume Ubuntu or another mainstream Linux distribution. OpenBSD works, but the author ran into friction with llama.cpp, the reference implementation for local inference. The switch to Linux and Ollama solved the compatibility problem while keeping the encrypted drive and stripped-down hardware configuration.
The AMD Ryzen 9 7940HS includes a neural processing unit branded as AMD Ryzen AI, capable of 10 TOPS (tera operations per second). Linux kernel 6.14, currently in development, should ship with AMDXDNA kernel modules that expose this NPU to user-space applications. If the NPU works as intended, it could improve inference speed without adding a discrete GPU.
The author expresses hope for this upgrade but notes that current performance is acceptable. That patience reflects a practical mindset: working with what's available now, rather than waiting for theoretical improvements.
What This Changes About the Local LLM Conversation
Most local LLM content focuses on maximum performance: which GPU to buy, how to quantize models for minimal quality loss, how to squeeze every token per second out of expensive hardware. This post asks a different question. What if you don't need maximum performance? What if "fast enough" is the right target?
For developers building AI tools that handle private data, the calculus is straightforward. A cloud API charges per token and sends every prompt to a remote server. A local machine costs a fixed amount upfront and keeps everything on-premises. The $537 entry point makes the local option accessible to individual developers, small teams, and organizations with strict data handling requirements.
For AI agents, the implications are similar. An agent running on a local machine can process documents, generate code, or answer questions without ever touching the internet. That's useful in air-gapped environments, regulated industries, or any context where data sovereignty matters.
The performance gap between local and cloud inference will narrow as hardware improves and models get more efficient. But the fundamental tradeoff is already clear: you can run real LLMs on real hardware, with no internet connection, for a few hundred dollars. The responses won't arrive instantly, but they'll be correct and private.
The author's closing observation sums it up: a fast GPU would be nice, but it isn't necessary. Local LLMs work on cheap hardware today.