pmcc93/omlx-helper-benchmarks

Native oMLX helper benchmarks — November 12, 2026

Apple M5 Ultra · 256 GiB · oMLX 0.7.4.dev1 · native MTP packs

New: complete illustrated field study (34-page PDF) · 8-page social carousel · all publication formats.

Combines the historical studies and current matrix, with measured Apple findings separated from Linux/DGX Spark implications. The original evidence below is unchanged; its manifest describes revision b109e52de6c889ef3e9700c7d0e8626dfc95d6bd. The added publication files have a separate manifest.

Full metric tables · Historical comparison tables · Practical helper checks · Targeted xhigh follow-up · Methods and limits · Model sources · Exact model revisions

My decision for this Mac

I'm sticking with stock Qwen Flash-Next oQ4e-MTP as the harder-task Codex helper. Swift made the long-context repair much faster, but its coding failures kept it from qualifying as a replacement. Codex ran the tests and still reviews helper answers, controls the tools, and makes the final decisions.

The practical comparison used six tasks at two seeds, with the existing helper's medium effort, 4,096 total tokens and 3,072-token thinking cap. Stock Flash4 passed 12/12 requests. Base6, Base8 and Swift4 each passed 11/12; Swift8 passed 10/12. Swift4 took 298.67 seconds versus Base4's 339.01, including its failed request. That's not an equal-correctness speed win. Swift4 and Base6 used a nonexistent UTF-8 decoder method. Base8 ran out of output space on one three-file response. Swift8 expired cache entries too soon and accepted an invalid dry-run value.

I also wanted to check whether giving Swift more reasoning would fix that problem. The bounded follow-up used the real helper prompt, sampled xhigh and 32,768 total tokens: two new seeds for the decoder case and one compact three-file request. Swift4 passed 2/3; Base4 passed 1/3. Swift repeated the same nonexistent decoder method even at xhigh. Base4 returned non-JSON prose once and incorrectly accepted integer dry-run values once. Neither met the predeclared clean-completion requirement. I didn't add a deep route or claim an aggregate speedup from those failed batches. The original failures are still in the tables. A later independent review found one additional cache bug in Base6. The post-review audit preserves the frozen scores and reports the added check separately: Base6 becomes 10/12 under the expanded checks; the other practical counts are unchanged.

That leaves stock Qwen27B for bounded everyday work, Ornith35B with its matching DFlash for faster drafts Codex can review, and stock Flash4 with native MTP for harder analysis. The earlier small-model studies didn't establish a reliable Swift27 or Ornith upgrade over stock27. Ornith35 keeps its narrower speed role; its weaker exact formatting and state tracing remain documented. GLM and its DFlash are still my personal reasoning and Hermes setup.

I retired Base6, both Swift trial packs and stock Flash8. The earlier Flash8 pilot had a one-answer advantage over Flash4 on 32 cases, and that result is still here. This newer comparison didn't establish an 8-bit quality advantage for the helper workflow, while its loading and generation were slower. This is a storage and latency decision for this setup, not a claim that 8-bit precision can never help.

The retained Flash4 profile uses native MTP at depth 3, A8 prefill, a 131,072 context cap, medium effort, a 3,072-token thinking cap and 4,096 total output tokens. All helpers stay unpinned with native TTL1. Unloading runs on the native maintenance cycle and takes several seconds. Actual prompts were tested through about 64K tokens; the larger context cap doesn't mean a full 131K prompt was validated.

Compatible native Swift builds already exist. I used the scottlowry Swift4 pack and Swift8 pack. Their exact revisions and file inventories are recorded here. This repository publishes the study, prompts, graders and historical evidence; the weights remain in their existing repositories.

These are small local studies with synthetic tasks and explicit budgets. They support a choice for this machine and runtime. They don't prove a universal ranking, a one-percent accuracy difference, unattended agent reliability, or measured cloud-bill savings.

What the measurements show

Swift's shorter reasoning made a substantial difference on the long-context problem, even though its raw prefill throughput was lower. All five packs finished the same synthetic three-file repair correctly at all three seeds, with no repair turn.

Swift4's median was 110.00 seconds versus Base4's 216.84: a 1.97× speedup and 51.63% fewer median thinking tokens. Swift8 took 142.16 seconds versus Base8's 324.52: a 2.28× speedup and 62.49% fewer median thinking tokens. These are three repetitions of one fully specified task. They don't establish the same saving across all coding work.

Swift8 produced fewer tokens than Swift4 but still took 29.23% longer at the median. Its larger files and offload policy matter when deciding what to keep. Base6 took 247.27 seconds without improving the long-task pass count. At a nominal 64K prompt, Base4's median prefill was 5,333 tokens per second and Swift4's was 4,472. Their decode rates were 127.0 and 135.9. Looking only at prefill would have missed the much larger difference in time spent generating reasoning.

The short greedy xhigh checks were far less successful. Base4, Base8, Swift4 and Swift8 each passed 2/5 coding tasks; Base6 passed 1/5. Most failures exhausted the 16,384-token cap. Swift8 also finished an answer that passed two arguments to codecs.getincrementaldecoder, whose factory accepts one. That's an actual Python API error, and it remains a failure. All five packs passed the separate two-step native tool-call protocol.

I wouldn't use those greedy cap failures as a general accuracy ranking. The practical check uses the actual helper request shape, medium reasoning, recommended sampled generation settings, a 4,096-token total limit and a 3,072-token thinking cap. Its results are reported separately.

Memory needs the right labels too. At 64K, native peak MLX allocation was about 115.28 GB for Base4, 116.18 GB for Swift4, 159.44 GB for Base6, 143.61 GB for Base8 and 143.68 GB for Swift8. Both 8-bit packs used SSD n-gram offload; the 4-bit and 6-bit packs didn't. These are deployment configurations with different resident weight placement, not whole-machine RAM measurements or a pure quantization comparison.

Evidence and provenance

Current raw results and frozen fixtures · Source archive · Historical evidence · Metric CSV · Historical CSV. Historical studies are separated into panels in HISTORY.md; their protocols differ and scores must not be pooled. GLM panels are historical personal/Hermes research, outside the new helper selection.

Report prose received an actual personal checkpoint-6 LoRA pass through the existing Q8 Humanizer, then Codex reviewed it and restored technical wording where needed. Structured measurements were never rewritten by that model. Public files omit credentials and local paths; one malformed analysis-like answer is represented by its hash, length and grade. The manifest records the published artifact hashes. Cleanup receipt: 663.315 GB observed free-space increase, including about 194.882 GB of preexisting Flash8 files and the new trial downloads/partials. Final runtime check confirms idle helpers, TTL1/unpinned and unchanged GLM/global settings.