BobClawblaw's TensorFold recipe: Ornith-1.5-122B (MLX 4-bit + DFlash2) on a Mac Studio

How fast it runs

Long prompts

Method: code+prose; 2 run(s) each; 512 tokens; 1 warm-up(s); median; context steps: prompts of exactly 16K, 32K, 64K and 128K tokens (a filler log first, the code or prose task prompt last), 2 runs per step, 512 output tokens; decode = tokens after the first / time after the first token; prefill = prompt tokens / time to first token of the same request, median over its requests; requests at once: C1,C2,C4,C8 at once; 2 rounds each; 512 tokens per request; prose prompt; total = all tokens / wall time, per request = tokens / end-to-end time; median over the rounds. Measured 2026-11-10. Raw files: speed result · speed contract · log.

Requests at once: the server has 4 slots (from the author's recipe). C8 exceeds the slots: the extra requests wait in the queue, and they were measured anyway. The speed test ran with BobClawblaw's recipe for this model (his repository BobClawblaw/ornith-15-122b-mlx-m5-ultra at commit bca26f24; the start command is the one his mac/config.py builds in lines 109 to 135 from the values of recipe.toml (lines 49 to 62, and the name in line 8, the model folder in line 14, the prompt cache in line 16, the drafter in lines 27 to 32, the host in line 45); both as I read them on 10 Nov 2026). The weights are the model publisher's own MLX 4-bit checkpoint, ornith-ai/Ornith-1.5-122B-MLX-4bit at revision 06a57aba (affine 4 bits, group size 64, router and shared-expert gate at 8 bits; 14 shards and a vision file, 64.8 GiB), not a quant of mine; the recipe pins this revision (recipe.toml, lines 10 to 16). The drafter is incoai/Ornith-1.5-122B-DFlash2 at revision a5ed7396 (1.7 GiB, pinned in recipe.toml, lines 27 to 32), its projections prepared in 4 bits by --drafter-bits 4. I downloaded both from Hugging Face and checked the sha256 of every large file against the hashes Hugging Face lists (18 model files and 2 drafter files, no mismatch). The engine is the official release archive tensorfold-1.2.5-macos-arm64 (tag v1.2.5, published by Ash Hart; archive sha256 563147f1, its binary tensorfold-native sha256 13ce9fcc), not built by me.

Differences from the author's recipe, all named: (1) The engine. The recipe builds TensorFold from BobClawblaw's own branch at commit 3b77807c3 (README, lines 16 to 19; local.example.toml, line 14); I used the official release 1.2.5 instead. Its changelog lists the Ornith-1.5-122B support in section 1.2.3 (CHANGELOG.md at tag v1.2.5, lines 528 and 603: pull requests #1799 and #1125, both by BobClawblaw). I did not test whether this release behaves exactly like his build. (2) The port: 8888 instead of 8891 (recipe.toml, line 46), as on all my Mac pages. (3) The launcher: I started the server with a small shell script that writes the same command that mac/config.py builds (shown on this page), not with his python3 -m mac up. TENSORFOLD_LIBTURBOJPEG points to the Homebrew JPEG library of this Mac; the engine's start line warns that this library is not libjpeg-turbo 3.1.4.1 and that JPEG images are refused until it is. This test is text only, no image input was sent. (4) The author's own measurements use his harness: 256-token greedy replies, drafts on, tokens per second added up over all streams, on engine commit 078e2247f or 3b77807c3 (README, lines 29 to 35). I measure with the sampling named on this page, 512-token replies, separate code and prose prompts, and the rate of one request, so his figures and these are not directly comparable, and this page makes no statement about them. (5) The draft streams: his README says that DFlash2 drafts one stream and the others decode plainly (line 47); the start line of the release in my log reads '4 streams of 262144 tokens, DFlash2 drafts for 4 streams'. I did not test which of the two holds, so this page makes no statement about it. Text only: no vision, no tool use and no agent task is measured.

The headline 119.3 tok/s is the mean of the code prompt (116.9) and the prose prompt (121.7), medians of two runs each (spread 8.2 % and 8.7 %). Thinking was off in every request, and the tool's cache check found no cached prompt tokens in any of the 60 requests it examined. The engine's draft counters: 35.6 % of the drafted tokens were accepted (1,317 of 3,698), 2.8 tokens per step on average. Requests at once: 1, 2, 4 and 8 requests ran together. The server has 4 slots (the recipe's --parallel 4), so with 8 requests at once 4 run and 4 wait: the engine's log (not published) shows the waiting requests queued for 11.3 to 15.5 s in the two rounds. The total rises from 106.2 tok/s with 1 request to 152.8 tok/s with 8; the speed of one request falls from 106.2 to 28.5 tok/s (the 1-request figure includes the prompt time, so it is below the decode speed). Context steps: prompts of exactly 16K, 32K, 64K and 128K tokens (128K = 131,072) were answered, all inside the 262,144-token window. The two decode runs of the 32K code step (118.6 and 95.6 tok/s) have a spread (CV) of 15.2 % (the tool flags a spread above 15 % as noisy); the spread of every other context step is below 15 %.

Six attempts: the table is the sixth attempt of the speed test (10 Nov 2026, 03:37 to 03:58, Berlin time). Five earlier attempts are not in it, and their files are not published. Attempts 1 to 4 were stopped by the load guard, which stops a step that is still disturbed after 3 repeated tries: attempt 1 (02:42) at the 32K prefill by the macOS menu bar helper (up to 100 % of one core), attempt 2 (02:46) at a test part of the older card list that this page does not use (a long building prompt) by a Python process (up to 102 %), attempt 3 (02:54) at the first round of 8 requests at once by the menu bar helper (up to 53 %), and attempt 4 (03:04) at the 32K prefill by the control center (up to 41 %). Attempt 5 (03:08 to 03:36) ran to the end, but its 64K prose step produced a reply of only 51 tokens (the tool needs at least 256), so only one of that step's two prose runs was valid, and I took no value from the attempt. Between the attempts I changed the guard's list of ignored programs: attempts 1 to 3 also ignored every program started from /Applications and /System/Applications, which I dropped because those patterns also hide Python processes (Xcode's Python lives there); attempt 4 ignored only the Claude Code session, the menu bar helper and a dictation helper; attempts 5 and 6 used the list that is in the contract of the table run. No value of the earlier attempts is mixed into the table.

Load on the Mac: the controlling Claude Code session and the macOS desktop shell (window server, Dock, Finder, system UI server, control center, notification center and the menu bar helper) ran on the same Mac during every attempt. They, and a dictation helper, are on the guard's ignore list, so they are not counted as foreign load and stopped no step of the table run. Other Apple system services are not on the list. The load guard (a sample every half second, 2,585 samples) threw away and repeated 5 of its 37 steps in the table run (6 repeats): in 5 repeats because Apple's audio service used more than 25 % of one core for two samples in a row (up to 51 %), and in one repeat because an Apple sync service (up to 34 %) and an ffmpeg process of the dictation helper ran in the same try. The repeats ran once the Mac was quiet again (the guard waited 5.2 s); the discarded tries are listed in the raw files. Readings above 25 % of one core that did not meet this rule still occur inside kept tries (28 of the 37 steps have one; the highest is 132 %, one single sample of an Apple performance service): the guard repeats a try only when a foreign process stays above 25 % for two samples in a row. The quiet check (one sample every 10 seconds) saw at most 103 % of one core, from the macOS menu bar helper. Before and after the run the tool found no foreign problem and had paused three macOS analysis services (media analysis, photo analysis and Spotlight indexing) while it ran. The sampling files of the table run (ruhe.csv, the guard's samples and the quiet checks before and after) are not published; its contract and its log are. So the Mac was not idle, and I cannot show that nothing else used it during the tests: the numbers are measured under this load.

python3 speed2.py --base-url http://127.0.0.1:50635/v1 --label mac256-run-ornith-s-speed-r5 --prompts $BENCH/repos/rigmark-v2/prompts-v2.json --output $RUN/mac256-run-ornith-s-speed-r5/mac256-run-ornith-s-speed-r5/speed2 --contract $RUN/mac256-run-ornith-s-speed-r5/mac256-run-ornith-s-speed-r5/speed2/speed-contract.json --parts decode,prefill,conc,ctx --prefill-depths 2048,8192,32768 --prompt-ids code,prose --runs 2 --max-tokens 512 --warmups 1 --prefill-runs 3 --conc-levels 1,2,4,8 --conc-rounds 2 --conc-max-tokens 512 --conc-prompt prose --ctx-depths 16384,32768,65536,131072 --ctx-runs 2 --ctx-max-tokens 512 --tokenizer-json $HOME/models/Ornith-1.5-122B-MLX-4bit/tokenizer.json --tokenizer-python $HOME/not published --sampling {"temperature": 0.6, "top_p": 0.95, "top_k": 20, "min_p": 0.0} --sampling-source Bob's recipe.toml:56 (temperature empty = the server's default sampling 0.6 / top_k 20 / top_p 0.95 = generation_config.json of ornith-ai/Ornith-1.5-122B-MLX-4bit @06a57aba). The model card (ornith-ai/Ornith-1.5-122B README 'Recommended sampling parameters') names 'precise coding' 0.6 / 0.95 / 20 / presence 0.0 and 'general tasks' 1.0 / 0.95 / 20 / presence 1.5; the recipe (Mac maker) uses 0.6 / 0.95 / 20, we follow the recipe and the card's coding set. No presence penalty (the recipe sends none). Seed 42 for speed/quality. --model Ornith-1.5-122B --no-cache-prompt --server-log $LOGS/server.log --engine-version-file $LOGS/engine-version.txt --server-slots 4 --server-slots-source recipe.toml:51 (parallel = 4, streams decoded together; Bob's README 'Settings' table: parallel default 4), passed as --parallel 4 (mac/config.py:110-111). DFlash2 drafts one stream, the others decode plainly (Bob README:47). C8 queues 4 requests by design (more requests than slots). --server-ctx 262144 --server-ctx-source Bob's recipe.toml:50 (context = 262144) and README 'Settings' table

How well it answers

Thinking off, except the last test. Seed 42. Sampling of the recipe (the server's default). A cut-off answer counts as wrong. Measured 2026-11-10.

Note from the run: MMLU-Pro (400 questions), GPQA Diamond (198), IFEval (200), LiveCodeBench (40 tasks) and RULER at 8K and 32K tokens (40 tasks each) ran with thinking off and the sampling of the recipe, which is the server's default (temperature 0.6, top-p 0.95, top-k 20), seed 42. Four requests ran at once (the 4 slots of the server; each question is its own request with the same limits and seed). MMLU-Pro and GPQA Diamond ran with an answer limit of 1,024 tokens (the other pages use 48), letter only; IFEval with 4,096 tokens; LiveCodeBench with 32,768 tokens; RULER with 128 tokens. Without thinking the model answers the multiple-choice questions with a letter at once (median 2 tokens); 9 MMLU-Pro answers ran into the 1,024-token limit and count as wrong, and 2 MMLU-Pro answers had no letter that could be read (they count as wrong too). 0 IFEval answers were cut off; 7 LiveCodeBench answers were cut off at their limit and count as wrong, and 2 LiveCodeBench answers contained no code. The other tests had none cut off. RULER by task: variable tracking 7 of 10 at 8K and 7 of 10 at 32K; multi-hop question answering 8 of 10 and 6 of 10; the other two tasks 10 of 10 each at both lengths. The thinking test (GPQA 30) ran with thinking on and a limit of 16,384 tokens: 6 of the 30 answers were cut off at the limit and count as wrong (median 3,705 tokens and 48.2 s per question, with 4 questions running at once). These quality tests have no foreign-load guard. The Claude Code session and the macOS desktop shell ran on the same Mac. The sampling file (not published) lists the busiest other process every 10 seconds: 83 of 398 samples were above 25 % of one core (up to 155 %): 60 of them the macOS desktop shell (menu bar helper and control center, up to 119 %), 12 Apple's audio service, 3 the virtual machine of the code sandbox of the LiveCodeBench test itself and 8 other processes (among them the peak of 155 %, a network extension of a VPN app). GPQA Diamond: the original is gated and no Hugging Face token was available, so the public mirror fingertap/GPQA-Diamond (198 rows) was used. Four raw files of the instruction run are not published, because the site's filter for machine names and power readings held them back: the MMLU-Pro answers (mmlupro.jsonl), the LiveCodeBench results and generations (lcb.jsonl and lcb.gen.jsonl) and the contract of the instruction run (quality2-contract.json; its note on foreign load names the network extension of a VPN app). The summaries and the log of every test are published, and the numbers of the table were counted from the complete files. These are my own tests, and no other run of this setup is mixed into the numbers on this page.

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts mmlupro --job mac256-run-ornith-q

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts gpqa --job mac256-run-ornith-q

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts ifeval --job mac256-run-ornith-q

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts lcb --job mac256-run-ornith-q

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts ruler --job mac256-run-ornith-q

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts ruler --job mac256-run-ornith-q

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts think --job mac256-run-ornith-q

How much context fits

Memory test. The recipe fixes the context (262,144 tokens), so the server is started once with the recipe's own command and reserves its memory up front. Then, for each size (4K, 8K, 16K ... up to the largest size tested), one prompt that fills about 95 % of that size is sent, and the model must answer. The largest size that answered counts; it is the highest size tested, not a limit of the setup. Decode speed at that size was not measured. Peak memory is the rise of used memory over the idle value before the server start (unified memory, so GPU and CPU share it). Measured 2026-11-10. Raw files: result of every step · log · contract.

Note from the run: Highest rise over idle: 125.77 GiB. The server was started once with the recipe's own command (the context is fixed at 262,144 tokens, recipe.toml, line 50) and it reserved its memory up front. Then one prompt of about 95 % of each size (4K, 8K, 16K, 32K, 64K, 128K and 256K) was sent, and the model had to answer. All seven sizes were answered. Six ended with the finish reason stop; the 16K answer reached the test's limit of 96 new tokens (finish reason length) and still counts as answered, because the test checks that the server answers, not what it answers. The largest size tested is 262,144 tokens (a prompt of 249,036 tokens), the whole window of the server, so the window is not only set but was filled to 95 %. The memory number is the rise of the Mac's used memory over its idle value before the server was started (a Mac has one pool of memory for CPU and GPU): the Mac had 31.04 GiB in use at idle; the rise over idle was 93.66 GiB when the server had loaded, 94.68 GiB during the 4K request, 114.46 GiB during the 128K request and at most 125.77 GiB during the 256K request. Because it is the rise of the whole Mac, other programs that used or released memory at the same time are inside the number. The tool checked for foreign load before the test (none found) and paused three macOS analysis services during it (media analysis, photo analysis and Spotlight indexing). This engine reports no timings for this memory test, so the decode speed and the first-token columns are empty.

bash tools/quality2/measure_all.sh tools/quality2/cards/ornith-122b-mlx4bit-tf-1.2.5-official-dflash2-m5ultra-1010.json --parts fit --job mac256-run-ornith-fit

How it plays the Gauntlet

One solo race, season seed 21, one attempt, no help.

Game rank as of Nov 10, 2026. The rank is the order of the Gauntlet finish times in this memory class. Race page and raw files.

The race ran the recipe named on its race page, with the sampling and answer limit of its lane config. The engine build of the race is not recorded in the race files.

Result (result.json) Race log (log.jsonl) Model answers (io.jsonl) System prompt Exact command Verify output Model config Race page

Also made this possible

• Engine (TensorFold 1.2.5, official release; Ornith support from pull requests #1125 and #1799 by BobClawblaw)Ash Hart@ashxhart GitHub Hugging Face Website
• Model (Ornith-1.5-122B)Ornith AIHugging Face GitHub Website
• MLX 4-bit weights (revision 06a57aba, published by the model's organisation)Ornith AIHugging Face GitHub Website
• Draft model (DFlash2, revision a5ed7396)Inco AI@inco_ai Hugging Face GitHub Website

Run it yourself

What you need and how to start it, step by step. The results below come from exactly this setup.

What you need

Hardware

Mac Studio M5 Ultra, 256 GB unified memory, one box (Darwin kernel 27.0.0)

System

macOS (the Mac above)

Model

ornith-ai/Ornith-1.5-122B (Qwen3.5-MoE 122B-A10B, vision tower, reasoning model), ornith-ai/Ornith-1.5-122B-MLX-4bit @06a57aba (MLX affine 4-bit, group 64, router and shared-expert gate 8-bit) + incoai/Ornith-1.5-122B-DFlash2 @a5ed7396 drafter

Model (Ornith-1.5-122B)

huggingface.co/ornith-ai/Ornith-1.5-122B

MLX 4-bit weights (revision 06a57aba, published by the model's organisation)

huggingface.co/ornith-ai/Ornith-1.5-122B-MLX-4bit/tree/06a57aba4fbae218efc9716bcdf7d6b3035331c8

Draft model (DFlash2, revision a5ed7396)

huggingface.co/incoai/Ornith-1.5-122B-DFlash2/tree/a5ed7396f5f9e5b1abf7ff50b7899a3186961432

Engine

TensorFold 1.2.5, the official macOS release (native Metal engine), the model publisher's MLX 4-bit weights with the DFlash2 drafter of Inco AI, 262,144 tokens of context per stream, 4 streams (as in the recipe) — the program that loads the model and answers requests · github.com/ashhart/TensorFold/releases/tag/v1.2.5

Recipe (BobClawblaw/ornith-15-122b-mlx-m5-ultra, commit bca26f24)

github.com/BobClawblaw/ornith-15-122b-mlx-m5-ultra/tree/bca26f24112322f65f5cec177b52708512f29a7b by BobClawblaw

Steps

1. Get the recipe, the engine and the model files from the list above.

2. Start the server with this command. It loads the model into memory. When the model has loaded, the server waits for requests on port 8888, only from this computer.

   Copy

   tensorfold-native serve \
     --host 127.0.0.1 \
     --port 8888 \
     --name Ornith-1.5-122B \
     --context 262144 \
     --max-tokens 50176 \
     --parallel 4 \
     --keep-warm 86400 \
     --no-update-check \
     --no-thinking \
     --thinking-budget 49152 \
     --drafter a5ed7396f5f9e5b1abf7ff50b7899a3186961432 \
     --drafter-bits 4 \
     --prompt-cache-gib 32 \
     --vision \
     --vision-image-tokens 4096 \
     --vision-max-images 4 \
     --vision-urls Ornith-1.5-122B-MLX-4bit

   The file names are the ones we used. Run the command in the folder that holds them, or put the full path in front of each name.

   What the parts mean

   • --parallel 4how many requests it answers at the same time
   • --host 127.0.0.1who can connect: only this computer
   • --port 8888the network port the server listens on
   • --drafter a5ed7396f5f9e5b1abf7ff50b7899a3186961432the draft model: it guesses the next tokens and the main model checks them; without it the model decodes plain
   • --name Ornith-1.5-122Bthe model ID the server advertises to clients

TensorFold 1.2.5 official release archive macos-arm64 (tensorfold-native, tag v1.2.5), DFlash2 drafts, --name Ornith-1.5-122B, --context 262144, --parallel 4, --no-thinking, prompt cache 32 GiB; TENSORFOLD_LIBTURBOJPEG=/opt/homebrew/opt/jpeg-turbo/lib/libturbojpeg.dylib tensorfold-native serve --host 127.0.0.1 --port 8888 --name Ornith-1.5-122B --context 262144 --max-tokens 50176 --parallel 4 --keep-warm 86400 --no-update-check --no-thinking --thinking-budget 49152 --drafter $HOME/.cache/huggingface/hub/models--incoai--Ornith-1.5-122B-DFlash2/snapshots/a5ed7396f5f9e5b1abf7ff50b7899a3186961432 --drafter-bits 4 --prompt-cache-gib 32 --vision --vision-image-tokens 4096 --vision-max-images 4 --vision-urls $HOME/models/Ornith-1.5-122B-MLX-4bit (BobClawblaw's recipe: the binary tensorfold-native comes from the official release archive tensorfold-1.2.5-macos-arm64; the command is the one that his mac/config.py builds in lines 109 to 135 from the values of recipe.toml (lines 49 to 62, and the name in line 8, the model folder in line 14, the prompt cache in line 16, the drafter in lines 27 to 32, the host in line 45), with the changes named in the speed notes: port 8888, the official release and TENSORFOLD_LIBTURBOJPEG pointing to the Homebrew JPEG library of this Mac; the model folder holds the files of the Hugging Face repository at revision 06a57aba, the drafter folder the snapshot at revision a5ed7396)