Local coding model comparison

Complete run · generated 2026-09-28 · run on an AMD Ryzen AI 9 HX 370 laptop, 62 GB RAM, no discrete GPU (Ollama ran on the CPU) · ollama version is 0.34.4

Bottom line

For everyday local coding on this machine, use Qwen3.6-35B-A3B with thinking off. It had the best average on the hard tasks (85%, averaged over three runs), a routine score of 97%, and the fastest generation (about 26 tokens per second). It finished the three hard tasks in about 6.5 minutes.

Best for a hard problem you can wait on: Qwen3.8-27B with thinking on. It was the only setup that fully solved the hard agent task (29 of 29 hidden tests), but that one task took about 10.6 minutes, and it is the slowest model here (6 to 9 tokens per second).
Qwen3.8-27B with thinking off was the only model with a perfect routine score (100%, one run), but it is about three times slower than Qwen3.6 and did not beat it on the hard tasks (79%, one run).
The two Qwen3-Coder models were the weakest on the hard tasks (62% and 67%). qwen3-coder:30b is about as fast as Qwen3.6 but less capable, so there is little reason to keep it for these tasks.
Thinking mode did not pay off on this hardware except for that one agent task. It made runs about 3 to 8 times longer. On the filter task both Qwen models (and Qwen3.6 on the expression evaluator too) used their whole 8,000-token budget thinking, so their answers were cut off and scored lower than with thinking off.

Other findings

Tool calling was reliable for every model: across 23 agent runs there were no invalid tool calls, no loops and no failed edits.
Passing the visible tests is not proof. Every model that fixed only some of the bugs still reported that everything was fixed, because the tests it could see passed. On the hard agent task, only the one perfect run (Qwen3.8 with thinking) was right when it said so.
Results vary from run to run. Qwen3.6 scored between 51% and 84% on the filter task across three runs, and qwen3-coder:30b scored 50% and 100% on the same refactor task at different settings. Treat gaps of a few points, and anything based on a single run, as uncertain.

Confidence: the ranking of the two Qwen3-Coder models below Qwen3.6 is fairly solid (three runs each). The comparison between Qwen3.6 and Qwen3.8 is not: Qwen3.8 has one run per task, so its hard score of 79% versus Qwen3.6's 85% is within the noise.

Follow-up: does a bigger thinking budget help Qwen3.6?

Afterwards I re-ran Qwen3.6-35B-A3B with thinking on and the token limit per reply raised from 8,000 to 16,000 (with a larger 32,000-token context window). On the hard agent task it scored 28, 24 and 25 of 29 across three runs (about 89% on average, against 83% with thinking off and 24 of 29 at the old limit), taking 6 to 10 minutes per run instead of about 3. It never reached the 29 of 29 that Qwen3.8 got with thinking on. On the filter task it used all 16,000 tokens (17.5 minutes) without writing an answer and scored 1 of 51. So more room helps a little on the agent task and does not fix the filter task. These runs are in a separate file and are not included in the tables above.

Overall

Each score is the share of hidden checks a model passed, averaged over tasks with equal weight (and over repeat runs where there are any). Routine is six everyday tasks; Hard is three harder ones. Speeds are medians; times are the wall time of the first run. Rows are ordered by hard score.

Model	Routine score	Hard score	Perfect tasks (of 9)	Generate tok/s	Read prompt tok/s	Time, 6 routine	Time, 3 hard	Cold load
qwen3.6:35b-a3b23 GB · 35.5B Q4_K_M · MoE, ~3B active	97%	85%	5/9	25.9	132	3.1 min	6.4 min	19 s
qwen3.8:27b18 GB · 27.3B Q4_K_M · Dense	100%	79%	7/9	8.6	23	6.7 min	11.4 min	18 s
qwen3.8:27b thinking on18 GB · 27.3B Q4_K_M · Dense	not run	78%	2/9	6.4	25	not run	39.7 min	17 s
qwen3.6:35b-a3b thinking on23 GB · 35.5B Q4_K_M · MoE, ~3B active	91%	72%	6/9	21.0	116	23.9 min	18.5 min	13 s
qwen3-coder-next:q2_k_l28 GB · 79.7B Q2_K · MoE, ~3B active	97%	67%	5/9	17.6	100	3.7 min	4.7 min	32 s
qwen3-coder:30b19 GB · 30.5B Q4_K_M · MoE, ~3B active	96%	62%	5/9	21.4	144	3.1 min	6.7 min	18 s

Score by task

Model	Merge intervals	LRU cache	Expression evaluator	Fix 3 bugs	Multi-file change	Agent loop	Filter compiler	Refactor	Hard agent
qwen3.6:35b-a3b	100%3 runs: 1.00–1.00	100%3 runs: 1.00–1.00	86%3 runs: 0.79–0.95	95%3 runs: 0.85–1.00	100%3 runs: 1.00–1.00	100%3 runs: 1.00–1.00	71%3 runs: 0.51–0.84	100%3 runs: 1.00–1.00	83%3 runs: 0.83–0.83
qwen3.8:27b	100%9/9	100%7/7	100%19/19	100%13/13	100%10/10	100%	53%27/51	100%22/22	83%
qwen3.8:27b thinking on	not run	not run	not run	not run	not run	not run	33%17/51	100%22/22	100%
qwen3.6:35b-a3b thinking on	100%9/9	100%7/7	47%9/19	100%13/13	100%10/10	100%	33%17/51	100%22/22	83%
qwen3-coder-next:q2_k_l	100%3 runs: 1.00–1.00	100%3 runs: 1.00–1.00	91%3 runs: 0.84–0.95	100%3 runs: 1.00–1.00	93%3 runs: 0.80–1.00	100%3 runs: 1.00–1.00	42%3 runs: 0.33–0.51	100%3 runs: 1.00–1.00	59%3 runs: 0.59–0.59
qwen3-coder:30b	100%3 runs: 1.00–1.00	100%3 runs: 1.00–1.00	79%3 runs: 0.74–0.84	100%3 runs: 1.00–1.00	100%3 runs: 1.00–1.00	100%3 runs: 1.00–1.00	40%3 runs: 0.35–0.43	83%3 runs: 0.50–1.00	63%3 runs: 0.59–0.66

For scale: a model that changes nothing on the hard agent task scores 52%; an answer that always returns false scores about 25% on the filter task; a refactor that returns an empty object scores about 5%.

Speed

Model	Generate tok/s	Read prompt tok/s	Cold load	Typical thinking length
qwen3.6:35b-a3b	25.9	132	19 s	—
qwen3.8:27b	8.6	23	18 s	—
qwen3.8:27b thinking on	6.4	25	17 s	4389 tokens (approx.)
qwen3.6:35b-a3b thinking on	21.0	116	13 s	5383 tokens (approx.)
qwen3-coder-next:q2_k_l	17.6	100	32 s	—
qwen3-coder:30b	21.4	144	18 s	—

Agent loop details

Model	Task	Hidden tests passed	Avg steps	How it ended	Median time
qwen3.6:35b-a3b	Agent loop	7/7, 7/7, 7/7	6.3	final-message, final-message, final-message	44 s
qwen3.6:35b-a3b	Hard agent	24/29, 24/29, 24/29	11.7	final-message, final-message, final-message	2.7 min
qwen3.8:27b	Agent loop	7/7	5.0	final-message	2.0 min
qwen3.8:27b	Hard agent	24/29	6.0	final-message	5.1 min
qwen3.8:27b thinking on	Hard agent	29/29	7.0	final-message	10.6 min
qwen3.6:35b-a3b thinking on	Agent loop	7/7	6.0	final-message	2.4 min
qwen3.6:35b-a3b thinking on	Hard agent	24/29	7.0	final-message	5.1 min
qwen3-coder-next:q2_k_l	Agent loop	7/7, 7/7, 7/7	4.3	final-message, final-message, final-message	41 s
qwen3-coder-next:q2_k_l	Hard agent	17/29, 17/29, 17/29	13.7	final-message, final-message, final-message	1.5 min
qwen3-coder:30b	Agent loop	7/7, 7/7, 7/7	8.7	final-message, final-message, final-message	42 s
qwen3-coder:30b	Hard agent	19/29, 17/29, 19/29	15.3	final-message, final-message, final-message	3.0 min

What was tested

Merge intervals — Algorithm: merge overlapping and touching intervals (9 hidden checks)
LRU cache — Algorithm: O(1) LRU cache class (7 hidden checks)
Expression evaluator — Algorithm: arithmetic parser with precedence, unary minus, errors, no eval (19 hidden checks)
Fix 3 bugs — Debugging: three planted bugs among five working functions (13 checks)
Multi-file change — Rename a field across 3 files and add validation (10 checks)
Agent loop — Tool-using agent fixes a failing project; scored on 7 hidden tests
Filter compiler — Hard algorithm: a search-filter parser with precedence, quoting, dotted paths and 16 invalid-input cases (51 hidden checks)
Refactor — Hard: refactor an 80-line pricing function into helpers without changing behaviour; compared with the original on 12 edge cases and 200 random orders (22 checks)
Hard agent — Hard: agent fixes a four-module billing library with 7 bugs, only 2 of which show up as failing tests; scored on 29 hidden tests (unchanged code scores 52%)

Every answer was scored automatically against hidden checks; the checks were first verified against a known-correct solution (100%) and a deliberately wrong one (low). Each model was cold-loaded, with a 16K-token context. Runs used temperature 0 (repeat runs used 0.3), thinking off unless marked, and a token cap per answer.

Limits

Six small JavaScript tasks are a narrow sample. They show whether a model handles routine coding and tool use, not how it performs on large or unfamiliar codebases, other languages, or long contexts.
Most models got one run; only the fast models got repeats, so small score differences (a few points) can be luck.
Speeds are for this machine, on the CPU, and will differ elsewhere. A GPU or different memory bandwidth changes the ranking of dense versus mixture-of-experts models a lot.
Thinking-mode runs used a fixed token cap; a model cut off while thinking may be scored lower than its true ability.