Qwen3.8 27B Addition Written in Words

Local Qwen3.8-27B reasoning on DGX Spark scored 167/169 word-sum tests, but one-shot limits, arithmetic, and number formatting still matter.

Oct 8, 2026 Updated Oct 8, 2026 0 views 0 comments

Key Takeaways

Qwen3.8-27B, when reasoning was enabled and run locally on a DGX Spark, answered 167 of 169 word-based arithmetic tests correctly.
The experiment followed an earlier GPT-4o test showing that language models still struggle with arithmetic and number-to-word formatting without calculator tools.
The local rerun compared reasoning disabled, which used 30 samples per condition and produced a heatmap, with reasoning enabled, which used one-shot answers and showed either full success or failure per test.
The result is not a formal benchmark: the one-shot setup may hide instability, and repeated tests are needed to judge reliability.
Local models can perform well on selected arithmetic tasks with reasoning enabled, but users should still verify exact calculations or use dedicated math tools.

Meta description: Qwen3.8-27B reasoning solved 167 of 169 local word-sum tests on a DGX Spark, while GPT-4o and 30-run tests show real arithmetic limits remain.

Tags: Qwen3.8-27B, GPT-4o, DGX Spark, model reasoning, local AI

Featured image: ![Abstract friendly illustration of arithmetic blocks turning into word bubbles, no people, logos or text](/images/qwen3-8-27b-reasoning-word-sum-tests.png)

This is for readers who want to understand how local large language models behave on number-to-word arithmetic tests. A follow-up to Colin Frasier's Bluesky post about an experiment he ran over two years ago using GPT-4o showed that Qwen3.8-27B, in a reasoning-enabled run on a DGX Spark, answered 167 of 169 attempts correctly when asked to compute sums and return the answers in words.

From a Bluesky chart to a local rerun

Colin Frasier's post described an older test in which GPT-4o was asked to calculate totals and spell the results in words across larger numbers. The shared chart showed performance changing as the numbers grew. The follow-up writer said they were confident GPT-4o had not used a calculator, because many answers were wrong. That limitation is common for language models: arithmetic and number-to-word output require stable token-by-token reasoning, not just fluent phrasing.

Then the follow-up moved the same idea to local hardware. The tester pasted Colin Frasier's image into a Codex Remote session (GPT-6 Astra) and had it repeat the experiment using Qwen3.8-27B-Q4_K_M.gguf. A GGUF file is a format for running trained models locally, and Q4_K_M is a quantized version that reduces memory demands. The point was to control the environment more tightly and see whether a locally hosted model could handle the task without depending on an unseen remote setup.

What the two test settings showed

The first local run used reasoning disabled and tested 30 attempts per combination. The result was presented as a heatmap, a grid where colors show success or failure across number ranges and answer formats. The excerpt did not provide a single accuracy total for that run, so readers should treat it as a visual snapshot of where the model struggled or succeeded.

The second run changed the setting: reasoning enabled. In this context, reasoning enabled means the model was allowed to work through more intermediate steps before answering. That took a lot longer per pair, so instead of running 30 samples per square, the tester ran just one. The heatmap became a much less visually appealing grid because each square was either 100% or 0%. In that one-shot style run, the report said the model gave the right answer in 167 out of 169 attempts.

The follow-up writer also said they expected a second run to produce different results, because the test was one-shot. That is an important caution. A small number of repeated attempts can reveal instability, while a single high-scoring run can still miss how a model behaves under different temperatures, prompts, or hardware conditions.

Why reasoning traces matter

The report included reasoning traces from some larger calculations. Reasoning traces are the intermediate steps a model may expose while working through a problem. Seeing them helps a reader understand whether a correct answer came from stepwise arithmetic or from a lucky surface pattern. In this case, the traces were part of the evidence that the local model was doing more than simply guessing at word forms.

The experiment is not a formal benchmark. It does not establish a general score for Qwen3.8-27B, GPT-4o, GPT-6 Astra, or any other model. It is a narrow task: add numbers, then express the total in words. That task combines two failure modes: numeric computation and formatting. A model may be strong at one and weak at the other.

What readers can take away

For anyone running local models, the value is in the method. The follow-up used a public chart as a prompt for a controlled rerun, then compared disabled and enabled reasoning settings. It also showed why sample size matters: 30 attempts per combination gives a smoother picture than one attempt per square.

For everyday users, the result suggests that local model setups can perform well on selected arithmetic tasks, especially when reasoning is enabled. But it does not mean such systems are reliable calculators. If a task requires exact math, users should still verify outputs, use tools designed for arithmetic, or test the model with multiple samples before trusting it.