younesai

DSpine on an M5 Ultra: Qwen3.8-27B from 43 to 134 tok/s

Tue, 10 Nov 2026 00:00:00 GMT

Qwen3.8-27B decodes at 43 tok/s on my Mac Studio M5 Ultra. With a 1.7 GB DSpine draft model attached, it decodes C++ at 133.7 tok/s. 3.1x, same machine, same quantization. At temperature 0 the output is identical token for token: the draft only changes the speed, not the text.

What DSpine is

Draft proposes5-layer drafter reads hidden states from 5 target layers, drafts 16 tokens in parallel
Target verifiesthe 27B checks the whole block in one pass
Accepted tokens are free7.4 tokens per verify step on code

DSpine is the successor to DFlash: a five-layer drafter that drafts a block of 16 tokens in parallel, with a code bridge and a transition table to keep the block causally consistent. The target verifies the block in a single pass and keeps the longest accepted prefix. Tencent released the draft weights; Ajay9o9 ported llama.cpp and quantized the draft. Upstream llama.cpp does not support DSpine yet, so you need his dspine branch.

The numbers

Idle machine, no other GPU work, median of 3 runs per case, 768 tokens generated, thinking mode off, exactly the protocol from the model card.

Decode speed by workload, tok/s

Workload	Baseline	DSpine	Speedup	Tokens per verify
C++ generation	43.5	133.7	3.1x	7.4
Code (Python)	43.4	127.7	2.9x	7.4
Math	43.4	118.7	2.7x	6.7
Long prompt (12,989 tok in)	43.4	99.6	2.3x	5.2
Temp 1 (Python prompt)	43.4	99.0	2.3x	5.6
Prose	43.6	52.5	1.2x	2.4

Structured content drafts well: code, math and C++ all accept around seven tokens per verify step. Prose is the worst case at 2.4, and it is also where the draft overhead eats most of the gain (1.2x). No run ever went below baseline.

Long prompts and temperature

A 12,989-token prompt still runs at 99.6 tok/s (2.3x). Acceptance drops to 5.2 tokens per step, the draft has less to latch onto once the context is dense. At temperature 1 acceptance drops to 5.6 and speed to 99.0 tok/s. The degradation is graceful: the draft never made a run slower than baseline.

Memory

Peak RSS: 19.8 GB without the draft, 23.3 GB with it. The draft costs about 1.7 GB in RAM. On 96 GB this is noise. On a 24 GB card it is a real trade-off: the model card reports ~64k usable context with DSpine against ~176k without speculation, because Qwen3.8 keeps a recurrent-state copy per drafted token.

M5 Ultra vs the RTX 3090

The same draft on a 24 GB RTX 3090, from the model card:

	RTX 3090	M5 Ultra
No speculation	~28	43.4
Code	128.7	127.7
Math	122.8	118.7

Two things fall out of this table. The 3090 and the M5 land within noise on speculative decode: the verify pass is compute-bound and both cards spend it at the same rate. The M5 wins on plain decode (43 vs 28 tok/s) thanks to memory bandwidth, which is why my speedup ratio looks smaller (3.1x vs the card’s 4.5x). The starting point is already faster. What transfers across hardware is the acceptance rate: 7.4 vs 7.6 tokens per verify on code, 6.7 vs 7.3 on math, 2.4 vs 2.5 on prose.

What I didn’t test

DFlash2 on Metal, so no drafter comparison on this hardware
Context beyond 13k input tokens
Multi-slot serving or batched requests
Quality at temperature > 0 (greedy output is identical by construction, so I only ran evals at temp 0)
The 180B model I run daily. No DSpine draft exists for it yet

Reproduce

git clone -b dspine https://github.com/Ajay9o9/llama.cpp.git
cd llama.cpp
cmake -B build && cmake --build build --config Release -j

./build/bin/llama-server \
  -m Qwen3.8-27B-Q4_K_M.gguf \
  -md Qwen3.8-27B-DSpine-b16-Q4_K_M.gguf \
  --spec-type draft-dflash --spec-draft-n-max 15 \
  -ngl 999 --spec-draft-ngl 999 -fa on --jinja -c 8192 -np 1

Weights: aj9o9/Qwen3.8-27B-DSpine-b16-GGUF (draft, Apache-2.0) + any Qwen3.8-27B Q4_K_M target. Raw runs: dspine-m5-ultra.csv. Paper: arxiv.org/abs/2609.36173.

Claude Fable 5.2: the price cut is the story

Tue, 10 Nov 2026 00:00:00 GMT

Anthropic released Claude Fable 5.2 and Claude Mythos 5.2 today. Both beat Opus 5.5 on almost every capability they evaluated. The benchmark wins are the headline. The price cut is the part that changes how you use them.

Prices

Fable 5.2 and Mythos 5.2 cost the same:

Model	Input / 1M	Output / 1M
Fable 5.2 / Mythos 5.2	$8	$40
Fast mode (same models, 2.5x faster)	$16	$80

Both are cheaper than the 5.1 versions. The page does not list the old numbers, so I will not guess them.

What the new prices buy, in plain arithmetic. A run that reads 1M tokens and writes 200k costs $8 + $8 = $16. The same run at Fast mode prices costs $32.

Benchmarks

On Anthropic’s own evals, Fable 5.2 beats Opus 5.5:

FableSWE v2, %

FrontierCode 2.0, %

The number I care about is not in a table: at High effort, Fable 5.2 lands roughly on par with Opus 5.5 at Max effort on FrontierCode 2.0, at about half the cost per task. Max effort is the setting that spends the most tokens per answer. Getting the same result from a cheaper setting is where the savings live.

Output is up to 30% faster than Fable 5.1 and Mythos 5.1. Both models take a 1M token context and write up to 128k tokens per response.

The demos

Two demos from the announcement, because they show what the model is aimed at:

Starting from an empty folder, the model coordinated over 1,000 subagents, working around the clock for eight days, and produced a working prototype operating system. It boots on a laptop, with its own kernel, drivers for disk, keyboard and network, persistent file storage, windows, a login screen, an installer, and built-in Claude functionality.
It formalized Fermat’s Last Theorem in Lean in under 30 hours, a first.

Both are prototypes, not products. The signal is the shape of the work: long, parallel, self-reviewing runs with many agents under one coordinator.

What this means for my daily driver

I run Opus 5.5 through Claude Code all day. My tracker shows the last 30 days at $1,199.57: 11.9M output tokens, 3.18B cache reads. Cache reads are the bulk of the volume, which is why the output price matters more than it looks: every token the model writes is the expensive part.

Anthropic still recommends Opus 5.5 as the daily driver and Fable for the large tasks. The company’s own guidance, and the one I agree with: most requests do not need the biggest model, and the effort settings matter more than the model choice. At High effort Fable 5.2 is about twice as fast as the default and still beats Opus 5.5 Max on the coding eval above.

Two patterns from the post are worth copying regardless of which model you pay for. The advisor pattern: Fable 5.2 plans, a smaller model executes. The orchestrator pattern: Fable 5.2 coordinates a team of subagents and decides when the work is done. Both buy speed or quality with architecture instead of with a bigger single bill.

What I didn’t test

I have not run Fable 5.2 myself yet. Every number here comes from the official announcement, fetched today.
Cache pricing for the new models is not published, so I cannot recompute my own bill at the new rates yet.
No long-context runs, no effort-level sweeps, no independent evals.

Once I can run it through my own stack, I will publish the measured version of this post, same as I did with the DSpine numbers.

Why I'm publishing my local AI numbers

Mon, 09 Nov 2026 00:00:00 GMT

Most local AI advice is either a vendor chart or a vibe. I wanted numbers I could trust, so I started measuring things myself: which model build to run, how fast it really is on my machines, and what an agent actually does when I hand it a task.

This site is where those measurements go.

What you’ll find here

Benchmarks: models measured on my own hardware, with the machine, runtime, settings and date written down.
Setup: the hardware and software behind it all, written so you can copy it.
Workflows: real Hermes agent runs, step by step, including the steps that failed.
Notes: short findings like this one.

The rules I hold myself to

Every number comes with its raw data. Every benchmark says what I did not test. If something turns out wrong, I correct the post and say so.

The first results are already up: nine model builds and four runtimes on my Mac Studio, on the Benchmarks page.