Dataset Viewer
Auto-converted to Parquet Duplicate
configuration
stringclasses
4 values
ctx
int64
512
65.5k
gen_tps
float64
12.3
17.7
ttft_s
float64
1.15
227
cold_prefill_trials
int64
1
3
prompt_tps
float64
289
462
peak_mem_gb
float64
16.4
32.9
memory_metric
stringclasses
2 values
spread
float64
0
0.23
arete-mlx
512
17.745893
1.177818
3
434.702028
16.395015
MLX allocator peak per trial
0.000821
arete-mlx
4,096
17.392459
8.875108
3
461.515532
18.263916
MLX allocator peak per trial
0.004256
arete-mlx
16,384
16.167775
41.586526
3
393.973763
19.068943
MLX allocator peak per trial
0.023715
arete-mlx
32,768
15.525882
82.730219
3
396.082598
20.143078
MLX allocator peak per trial
0.025031
arete-mlx
65,536
13.696641
194.289346
3
337.311341
22.399696
MLX allocator peak per trial
0.038505
qwen-mlx
512
17.060638
1.594921
3
321.018934
16.395032
MLX allocator peak per trial
0.042505
qwen-mlx
4,096
17.189228
8.970985
3
456.583086
18.26326
MLX allocator peak per trial
0.013443
qwen-mlx
16,384
16.294773
39.231718
3
417.621273
19.068681
MLX allocator peak per trial
0.018019
qwen-mlx
32,768
15.317451
84.17567
3
389.281129
20.142964
MLX allocator peak per trial
0.128897
qwen-mlx
65,536
12.271795
187.95616
3
348.677053
22.399368
MLX allocator peak per trial
0.234111
arete-tf
512
17.222824
1.155334
3
443.161971
32.888123
TensorFold physical-footprint-backed device peak, since start/health reset
0.123335
arete-tf
4,096
16.64271
9.531496
3
429.73319
32.888582
TensorFold physical-footprint-backed device peak, since start/health reset
0.015007
arete-tf
16,384
15.946761
43.395967
1
377.546609
32.888828
TensorFold physical-footprint-backed device peak, since start/health reset
0.044929
arete-tf
32,768
14.924017
91.29242
1
358.934508
32.889286
TensorFold physical-footprint-backed device peak, since start/health reset
0.010308
arete-tf
65,536
13.055309
219.078125
1
299.144427
32.890122
TensorFold physical-footprint-backed device peak, since start/health reset
0.009266
qwen-tf
512
16.832501
1.152712
3
444.16973
32.887779
TensorFold physical-footprint-backed device peak, since start/health reset
0.12222
qwen-tf
4,096
16.090234
9.791169
3
418.336136
32.888156
TensorFold physical-footprint-backed device peak, since start/health reset
0.075239
qwen-tf
16,384
15.28757
42.871682
3
382.163687
32.888402
TensorFold physical-footprint-backed device peak, since start/health reset
0.011535
qwen-tf
32,768
14.561166
93.593856
3
350.10845
32.888861
TensorFold physical-footprint-backed device peak, since start/health reset
0.023192
qwen-tf
65,536
12.709415
226.824646
3
288.928038
32.889729
TensorFold physical-footprint-backed device peak, since start/health reset
0.021151

Arete-27B vs Qwen3.8-27B on my 64GB M5 Pro Mac mini

Measured on November 7, 2026 (America/Vancouver, PDT, UTC-7).

I ran Nous Research's Arete-27B against its Qwen3.8-27B base on my 64GB M5 Pro Mac mini, using matching 4-bit-class builds on MLX and TensorFold 1.2.4. Arete stayed in the same generation-speed band as Qwen across the five measured input lengths. TensorFold 1.2.4 loaded the community Arete build directly and ran both models through the planned 64K point.

At 512 input tokens, Arete generated at 17.75 tok/s on MLX and 17.22 tok/s on TensorFold; Qwen measured 17.06 and 16.83 tok/s. At 65,536 input tokens, Arete measured 13.70 and 13.06 tok/s; Qwen measured 12.27 and 12.71 tok/s. The noisy Qwen/MLX 64K point is not a precise model ranking. These sequential runs do not isolate runtime or training effects from background contention.

My small MLX-only quality suite scored Arete 67/69 and Qwen 69/69. Both found all 11 long-context needles. I did not rerun Nous's values eval. These are my measurements, not a reproduction of Nous's published benchmark scores.

The setup

  • Apple M5 Pro Mac mini, 64GB unified memory, macOS 27.0.1 (26A434), AC power.
  • A background inference app was running and was not paused.
  • MLX 0.32.4, mlx-lm 0.32.2, tensorfold-native 1.2.4. Captured Python environment: Python 3.12.15, transformers 5.22.2, huggingface-hub 2.4.0.
  • Temperature 0, thinking off, seed 1234, 256 generated tokens for the speed workload. Suite v1 + deep-v1, with the explicitly named run-adapter-v1.
  • One discarded warmup, then 3 timed generation trials per length. Median reported. If generation spread exceeded 10%, another 3 trials were taken and the rerun median retained. Initial and repeated trials remain in the raw files.
  • The same fixed prompt manifest was used. Both models' 74 chat renderings and token sequences were validated against it. TensorFold used one request at a time, a 66,560-token context window, and no speculative drafts.
  • Cold TTFT counts are separate from generation trial counts. Arete/TensorFold has only one retained cold sample at each of 16K, 32K and 64K.

Results

Generation is median decode throughput. TTFT is uncached request-to-first-token latency, excluding loading. Prompt tok/s is input tokens divided by client TTFT, a prefill proxy including first-token/request overhead, not isolated kernel throughput. Decimal GB is used for memory. The CSV retains full precision.

Configuration Input tokens Generation tok/s Cold TTFT s Cold N Prompt tok/s Reported peak GB
Arete / MLX 512 17.75 1.18 3 434.70 16.40
Arete / MLX 4096 17.39 8.88 3 461.52 18.26
Arete / MLX 16384 16.17 41.59 3 393.97 19.07
Arete / MLX 32768 15.53 82.73 3 396.08 20.14
Arete / MLX 65536 13.70 194.29 3 337.31 22.40
Qwen / MLX 512 17.06 1.59 3 321.02 16.40
Qwen / MLX 4096 17.19 8.97 3 456.58 18.26
Qwen / MLX 16384 16.29 39.23 3 417.62 19.07
Qwen / MLX 32768 15.32 84.18 3 389.28 20.14
Qwen / MLX 65536 12.27 187.96 3 348.68 22.40
Arete / TensorFold 1.2.4 512 17.22 1.16 3 443.16 32.89
Arete / TensorFold 1.2.4 4096 16.64 9.53 3 429.73 32.89
Arete / TensorFold 1.2.4 16384 15.95 43.40 1 377.55 32.89
Arete / TensorFold 1.2.4 32768 14.92 91.29 1 358.93 32.89
Arete / TensorFold 1.2.4 65536 13.06 219.08 1 299.14 32.89
Qwen / TensorFold 1.2.4 512 16.83 1.15 3 444.17 32.89
Qwen / TensorFold 1.2.4 4096 16.09 9.79 3 418.34 32.89
Qwen / TensorFold 1.2.4 16384 15.29 42.87 3 382.16 32.89
Qwen / TensorFold 1.2.4 32768 14.56 93.59 3 350.11 32.89
Qwen / TensorFold 1.2.4 65536 12.71 226.82 3 288.93 32.89

The memory columns are not equivalent metrics. MLX is allocator peak per trial. TensorFold's approximately 32.89 GB is a physical-footprint-backed server device peak, with since-start/health-reset scope captured in the raw files. I am not claiming a RAM-efficiency win for either runtime. TensorFold's fixed context reservation also differs from MLX's on-demand cache growth.

Generation throughput with retained min-to-max ranges

Cold first-token timing and native prompt reuse

TensorFold cold TTFT and prompt tok/s use only non-warmup observations with cached_tokens=0 and TTFT at least 0.5 seconds. Arete/TensorFold at 16K, 32K and 64K is N=1, because two of the three timed trials hit the in-memory cache. Other cold points in the table are N=3. Generation columns retain the perf.json medians and are not filtered to cold-only trials.

Repeated identical prompts hit an in-memory cache even with --prompt-cache-gib 0. Cache-hit median first-token latency was approximately 67 to 95 ms across these observations. That is a useful runtime reuse feature, not cold compute speed. The complete cache-hit observation counts, cached-token counts and latencies are in native_prompt_reuse_observations.csv; they are deliberately separate from the cold table. No equivalent MLX reuse experiment was run, so this is not a cross-runtime cache comparison.

Uncached first-token latency; hollow markers denote N=1

Residual variability

Spread here is (max - min) / median, not a confidence interval and not the spread definition used in some of my other notes. These are the remaining retained generation spreads after the recorded reruns:

Configuration Input tokens Remaining spread Generation min to max tok/s
Qwen / MLX 32,768 12.9% 13.40 to 15.37
Qwen / MLX 65,536 23.4% 10.54 to 13.41
Arete / TensorFold 1.2.4 512 12.3% 15.14 to 17.26
Qwen / TensorFold 1.2.4 512 12.2% 14.88 to 16.94

The rerun trigger applied to generation-throughput spread, not independently to TTFT or prompt throughput. Three samples are small, and the long-context Arete/TensorFold cold points have only one. No additional benchmark was run to improve those sample counts before publication.

Quality: MLX only

Build on MLX Math Code Instructions Hard math Hard code Tools Needles Total
Arete-27B 20/20 9/10 9/10 8/8 5/5 5/5 11/11 67/69
Qwen3.8-27B 20/20 10/10 10/10 8/8 5/5 5/5 11/11 69/69

The 69 checks comprise 58 ordinary quality prompts plus 11 needle checks, not two different quality totals. The needles include 8 ordinary and 3 distractor tests, through the planned 64K point.

Arete's two misses were specific: word_freq omitted comma handling in a Python task, and a response had 61 words against a requested 40-to-60-word limit. Both models passed the harder math, harder code and synthetic tool-call checks. No real external tools were executed. None of the quality outputs hit its length cap.

These fixed automatic checks are small, not a standardized public leaderboard. Code success means passing the supplied tests, not exhaustive correctness. Different conversion provenance is a quality confound, so the two misses cannot be attributed solely to fine-tuning. There was no TensorFold quality run, and I make no cross-runtime quality-equivalence claim. I did not rerun Nous's values eval.

Local MLX quality checks, not Nous's values evaluation

Builds, quantization and revisions

Role Build Exact measured revision
Arete community conversion Duckets/Arete-27B-MLX-4bit bd3f7163ded581ead599600681f3400e7e5634e0
Qwen conversion in both runtimes TensorFold/Qwen3.8-27B-MLX-4bit 22d8d538154e0e5b6f8dcb1fcc74a60a0798104c

Both are affine 4-bit, group size 64. The Arete converter lists approximately 4.695 bits per weight. Header reconstruction measured 4.694790082019954 overall stored bits per weight and 4.501131145811178 for text tensors, including quantization overhead and higher-precision tensors. Both MLX builds recorded loaded_tensor_bytes=15132802048, or 15.132802048 GB of text tensors. This is not the same as runtime peak memory. TensorFold loaded the corresponding same model folders; server footprint is reported separately.

Each downloaded checkpoint totals 16.054541349 GB of safetensors files including unused BF16 vision tensors; the inference and quality work here is text-only. I did not evaluate vision, fine-tuning, BF16, 8-bit, or the models' full supported-context limits. The Arete conversion is community-provided, not Nous's own quantization. Matching 4-bit/group64 class does not prove an identical conversion pipeline.

model_intel.json records exact source revisions and file metadata. The source Nous Arete revision is 108f0afbdcfaa1ceeda4a635004304dfff6d4da2; the inspected upstream Qwen revision is 37561816e66b5b9153b1b64c10968c18c1e6f4a0. These upstream revisions are provenance, not extra measured configurations. No model weights are redistributed.

Timing and fairness limits

  • The runs were sequential, not interleaved. Background load changed. These results show what I observed on my desk, not an uncontended hardware ceiling or a causal runtime speedup.
  • MLX TTFT ends at the first generated-token response; TensorFold ends at the first nonempty streamed content delta. Tokenization, HTTP, serialization and detokenization boundaries differ. This is not a controlled kernel microbenchmark.
  • Cold in this card means an uncached prompt, not cold filesystem caches or cold process startup. Loading is excluded from the reported speed and TTFT table.
  • TensorFold memory is server-scoped, not a directly comparable replacement for MLX allocator peak. Memory scopes and sources are preserved in raw JSON.
  • The tensor-geometry bandwidth figures in results_summary.md are estimates, not hardware counters. The recorded 307 GB/s hardware specification was not reverified in this run. TensorFold KV estimates exclude recurrent state. They are not extra measured benchmark scores.
  • The initial Qwen tokenizer warning concerned filler-pool construction. Actual speed inputs were validated at 512, 4096, 16384, 32768 and 65536 tokens. Every recorded speed output was 256 generated tokens, as checked in validation_audit.json.
  • Raw timestamps retain the source machine's zone labels. They are provenance logs, not a changed execution schedule. The measurement date above is in America/Vancouver.

Reproduce and inspect

See exact_commands.md for the original preparation and measured invocations. Native server commands were:

tensorfold serve /Users/pratik/launch-benchmarks/arete-27b-2026-11-07/models/arete --name local-model --host 127.0.0.1 --port 18087 --context 66560 --parallel 1 --temperature 0 --no-thinking --prompt-cache-gib 0 --no-drafts --no-update-check
tensorfold serve /Users/pratik/launch-benchmarks/arete-27b-2026-11-07/models/qwen --name local-model --host 127.0.0.1 --port 18087 --context 66560 --parallel 1 --temperature 0 --no-thinking --prompt-cache-gib 0 --no-drafts --no-update-check

Obtain the two exact model revisions separately under their licenses and adapt the absolute paths to your machine. Review scripts before running them and prefer a dedicated environment. run_benchmark.py expects the original suite at a sibling suite/ folder; copy suite_snapshot/ there, preserving its files. It expects model folders at models/arete and models/qwen under its own run directory. Preserve the supplied prompts.json to reuse the exact fixed prompts and token IDs. No weight folders are included here.

  • official_four_config_table.csv: 20 official measured summary rows, full precision, with cold sample counts and memory metric labels.
  • results_summary.md: detailed sanitized report, including estimated quantities clearly labeled as estimates.
  • results_rows.csv, summary_rows.json: combined summaries with retained trials, environments and metadata.
  • arete-mlx/, qwen-mlx/, arete-tf/, qwen-tf/: per-configuration perf.json, speed trials, environment, completion, tensor geometry, MLX loaded-tensor data, TensorFold server commands/memory/logs, and available template validation. MLX folders include quality responses, scorers and needles; TensorFold folders are speed-only. Top-level configuration logs are also retained.
  • native_prompt_reuse_observations.csv, cache_protocol_note.md: separate native cache-reuse audit.
  • quality_behavior.csv, validation_audit.json, quantization_measured.json, model_intel.json, template_validation_all.json: quality, validation and provenance records.
  • run_benchmark.py, run_all.sh, suite_snapshot/, prompts.json, exact_commands.md: runner, orchestration, unchanged suite snapshot, fixed prompts and original commands.
  • charts/: all three charts. Root copies are provided for README-relative rendering.
  • packet_manifest.json: original completion metadata, explicitly labeled as pre-publication counters. MANIFEST.sha256 was regenerated for the sanitized public files, excluding itself. publication_sanitization.json lists metadata-only publication edits and original-source hashes.

Apple resource forks, generated caches, duplicate archives, social drafts, status notes, hardware identifiers, credentials, model weights and unrelated home-directory data are excluded. Background process names are omitted while their CPU/RSS observations and the benchmark measurements remain. No private correspondence is included.

Licenses and credit

Measurements and documentation: CC BY 4.0, attribution Pratik Gandhi. License text.

The model checkpoints are separately Apache-2.0; that license is not replaced by the benchmark license. Existing code retains any original license notices. No model weights are redistributed.

Credit to Nous Research for Arete, Qwen for the base model, TensorFold for its runtime and Qwen conversion, Duckets for the community Arete build, and the MLX team for the Apple Silicon stack. I can check a new fine-tune against its base on a machine I already own, with the caveats alongside the numbers.

Links

Write-up on GitHub

How I ran this, what broke, and the scripts: Arete-27B and Qwen3.8-27B. It's part of Local AI field notes, where I log every model I run on my Mac mini.

Downloads last month
296