An M5 Ultra with 96 GB runs Qwen3.8 Flash Next on sushi, my agent, and about 40 containers. Here is where the memory goes and why I chose sushi.
chip
M5 Ultra
unified memory
96 GB
tokens of context
262K
failed requests, 3-day snapshot
0
One Mac Studio runs it all
A Mac Studio with the M5 Ultra and 96 GB of unified memory. The CPU and GPU share that memory, which is what makes a 180-billion-parameter model practical at home: no graphics card with its own small memory to squeeze it into.
Chip
Apple M5 Ultra, 30 CPU cores (10 Super, 20 Performance), with neural accelerators in the GPU
Memory
96 GB unified. I let the GPU lock up to 86 GB of it (macOS allows less by default), set at every boot.
System
macOS 27.2
Main model
Qwen3.8 Flash Next, a mixture-of-experts model with a 262K-token context, packed at 2.75 bits per weight
Model server
sushi 1.5.1, built on Apple's MLX 0.32.3
Up since last restart
3 days 4 hours, 5,162 requests, 0 failed (9 Nov 2026)
Where the 96 GB go
The model server takes about half the memory. The rest runs my other services: a second model server for smaller models, about 40 Docker containers, and the usual apps. This is a snapshot from 9 November, not a plan, and it's tight: only a few GB are free.
Unified memory right now, GB
GPU limit 86
sushi + Qwen3.8 Flash Next 50
oMLX, for the 27B models 16
Docker containers (OrbStack) 15
macOS and apps 9
Free 6
What the model needs at full context, GB
Weights, 2.75 bits 44.9
Attention cache at 262K tokens, 8-bit 7.9
Prompt cache kept in memory 2
On the SSD, GB
Weights 45
Lookup table for drafting 30
Prompt cache on SSD (budget) 20
The attention cache figure is an estimate from sushi's own memory check; the rest is measured. The lookup table and the SSD cache are read from disk as needed and don't count against memory.
Why sushi
sushi is an open-source model server for Apple Silicon, a fork of mlx-serve with its own low-bit format. I tried four runtimes on the same hardware (all the numbers). sushi won on the things my agent does all day: long prompts, fast answers, the same prompt prefix over and over.
95.4tokens/s
writing French with a 128K-token prompt. mlx-serve: 78.8.
+29%writing speed
against oMLX on the same model, and 2,412 vs 1,356 tokens/s reading a long prompt.
44.9GB of weights
at 2.75 bits, against 50.6 GB at 3.3 bits. Blind-graded French: a tie.
96%of prompt tokens
came from the cache on the SSD instead of being computed again.
68%of guesses kept
The model drafts the next tokens and checks them in one pass. Same output, faster.
3APIs, one port
OpenAI, Anthropic and Ollama, with tools, vision and JSON schema.
Where it lost: the 3.3-bit build on mlx-serve passed 32 of 32 tool calls against 29 for sushi's 2.75-bit build. Counters are from sushi's metrics on 9 November.
How it's served
One command, started at login and restarted automatically if it ever stops.
Mac boots
GPU limit raisedto 86 GB, every boot
sushi startsat login, model loaded
Restarted if it stopswithin 30 seconds
Every flag, in plain words
Flag
What it does
--model Qwen3.8-Flash-Next-Sushi-STQ-2.75bpw
Load this one model folder: Qwen3.8-Flash-Next packed in Sushi's own 2.75-bit format.
--host 127.0.0.1
Listen on this Mac only. Nothing on the network can reach it.
--ctx-size 262144
Allow prompts up to 262,144 tokens (256K), the model's native context.
The pack ships with a static YaRN x4 stretch for 1M context. Setting the factor to 1.0 switches it off and caps context at the native 256K, because static YaRN hurts quality on short texts (plist note).
--max-tokens 32000
If a client does not say how long the answer may be, allow up to 32,000 tokens (room for long reasoning).
--kv-quant 8
Store the attention memory (KV cache) in 8-bit instead of 16-bit: half the RAM per token of context.
--mtp-head-kv-quant
Also store the speculative MTP head's own KV cache in 8-bit (by default it stays 16-bit).
--temp 0.6
Default sampling temperature. 0.6 beat 1.0 on tool calls, hard evals and a signature task (plist note; temp-t06.json vs temp-t10.json).
--top-p 0.95
Sample only from the most likely tokens that add up to 95% probability (Qwen's recommended value).
--top-k 20
Never consider more than the 20 most likely next tokens (Qwen's recommended value).
--max-concurrent 4
Size the queue for 4 parallel requests; requests are batched together on the GPU.
--prefix-cache-disk 20GB
Save already-processed prompt prefixes to the SSD (up to 20 GiB) so a repeated system prompt or conversation is restored, not recomputed, even after a restart.
--prefix-cache-mem 2GB
Keep up to 2 GiB of the hottest prefixes in RAM as well, for instant reuse.
(default) MTP speculative decoding
Not a flag here because it is on by default for Qwen: the model's built-in multi-token-prediction head drafts several tokens ahead and the main model checks them in one pass, plus prompt-lookup drafts from the n-gram table. Same output, more tokens per second.
Who talks to it
Nothing outside the Mac can reach the model server. Everything that needs a model goes through it locally.
Hermes Agent
My always-on agent. Its main model and the helper that compresses long conversations both run here. What it does
LiteLLM
A small router in Docker: Flash Next goes to sushi, the 27B models to oMLX, anything else to Ollama. Tools that only know one API point here.
The benchmarks
The same endpoint the agent uses, so the numbers match what the agent gets.
The agent goes straight to the model
Hermes Agent
sushiQwen3.8 Flash Next
Everything else goes through a router
n8n and other tools
LiteLLMpicks the server by model name
sushi, oMLX or Ollama
What I tried first
Every alternative ran on this Mac, through the same tests.
Runtime and model
Result
Why I moved on
mlx-serve 26.11.1 (sushi's upstream) + Qwen3.8-Flash-Next iQ 3.3bpw
Decode 99/143 tok/s (prose/code) at 1K, 79/100 at 128K; prefill 563/916 at 1K. Tools 32/32 and quality 16/16 at temp 0.6; blind writing 97.5/120; French MCQ 26/30.
Slower at long context and on short-prompt prefill, ~6 GB more weights. Quality was a tie (it even scored better on tools: 32/32 vs 29/32).