The 1.7B Qwen3 That Outperformed Six Bigger Models on a NAS
In a test of seven local LLMs on a Ugreen DH4300 Plus, Qwen3 1.7B was the only one that balanced speed, tool-call accuracy, and restraint for smart home control.
Source material: xda-developers.com
The NAS Reality: 6 TOPS That Never Help
The Ugreen DH4300 Plus advertises 6 TOPS of AI performance, enough for a Rockchip RK3588C with eight ARM cores and 8GB of memory. But Ollama ignores the NPU in a standard Docker container, so every model runs on the CPU. That puts the practical ceiling around 2B parameters for interactive smart home commands. Quantized 3B and 4B models load, but they compete with everything else the NAS is doing. The result is that most of the seven models tested on this box had to operate under a handicap before the first request was sent. FunctionGemma 270M, Qwen3 0.6B, and the others all faced the same constraint: no GPU offload, no NPU acceleration, just eight ARM cores and a shared memory pool. The difference between loading a model and actually using it is where the test started to separate the candidates.
Why a 3B Model Is Often Too Big
Home Assistant amplifies the load. It sends entity names, current states, and tool definitions as context before the model sees the user's request. Even a single light command carries that overhead. The Home Assistant documentation suggests exposing fewer than 25 entities to small local models; the test kept only 10 to 15. A comparable Synology DS224+ with its Intel Celeron J4125 and 2GB of memory (expandable to 6GB) leaves even less headroom once DSM and containers take their share. The TerraMaster F4-424 starts from a better place with an Intel N95 and 8GB of DDR5, but it still can't offload inference to a GPU. More memory doesn't shrink the prompt. A 3B model like Llama 3.2 or a 3.8B Phi-4 Mini might handle natural language better, but the growing context pushes them past their latency budget. The test kept the entity list deliberately small, yet even that wasn't enough to make the larger models practical.
Seven Models, Six Failures
The smallest, FunctionGemma 270M, returned calls quickly but got confused when multiple tools or similarly named entities appeared. Google positions it as a base for fine-tuning, not a finished general-purpose model. Home-FunctionGemma, also 270M, was trained on 240,000 Home Assistant requests and understood Assist API structures much better, but its narrow training made it brittle outside familiar phrasing. Qwen3 0.6B supported tools via Ollama but dropped accuracy on ambiguous or multi-device commands. LFM2.5 1.2B often picked the right function but returned it in Python-style output that Home Assistant couldn't parse. Llama 3.2 3B and Phi-4 Mini 3.8B were slower and no more reliable. Only Qwen3 1.7B consistently returned valid tool calls and understood when to do nothing. The test gave each model the same ambiguous requests, like a command that should not trigger any action, and only Qwen3 held the line across every category.
The Winner's Recipe
Qwen3 1.7B's Q4 quantized version weighs 1.4GB, but it doesn't need more than a 4,096-token context window. The test ran it with thinking disabled, temperature near zero, and only two to four messages of history to keep the context lean. The model stayed loaded in memory between requests, avoiding startup latency. It handled ambiguous phrasing like 'it's getting dark in here' by selecting the right light tool without triggering unrelated devices. The key was to let Home Assistant's built-in Assist handle straightforward commands first and route only the more interpretive requests to Qwen3. This hybrid setup keeps fast responses for basic tasks like 'turn off the kitchen light' while offloading the fuzzy language to the LLM. The model's tool-call format was native to Ollama, so no extra parsing layer was needed between the NAS and Home Assistant.
Where to Draw the Safety Line
Even with the reliable model, the test stopped short of giving it control over locks, heaters, or alarms. Those remain deterministic automations. The LLM's value is interpreting language and picking from a tightly restricted set of actions. That's enough to make natural-language control work without letting a small local model make risky decisions. The entity list stays small, the context window stays short, and the model never acts without a tool call that matches a predefined action. A direct command like 'lock the front door' still goes through the regular Assist pipeline, not through Qwen3. The model only sees the vocabulary of allowed tools and the current states of those entities. This division of labor keeps the most sensitive components out of the hands of a language model that could misinterpret a vague phrase under load.
Where this came from. This breakdown is based on source material published at xda-developers.com. Images above are used with the credits shown beneath each one.