Every open-weight release this year has made the same bet: a few hundred billion parameters, a sparse router, and twenty to fifty billion of them awake for any one token. It is the sensible bet when the buyer has a rack. It leaves everyone with one card asking what they are supposed to run, because a 500B checkpoint does not fit on 96 GB at any quantization anyone ships.
Ricursive Intelligence went the other way in early November with Ripple-65B Preview: 65 billion parameters, dense, every one of them used on every token, with a 4-bit NVFP4 checkpoint that loads on a single workstation-class GPU. The open-weight models it lists itself against carry 501B to 975B parameters and activate 23B to 55B per token. Ripple activates all 65B and still fits at home. That is a bold thing to ship in a year of mixtures, and it comes with an obvious bill: a dense model has no cheap tokens.
So we put it on one RTX PRO 6000 Blackwell Server Edition, 96 GB, and measured what it takes to make that bill acceptable. Plain decoding gives 22.7 tokens per second for one user. With the vendor’s DFlash 2 drafter on the same card, one user gets 55.6 on prose and 87 on code, 32 concurrent prose streams get 833 in aggregate at 300 W, and the same server reaches 1,053 when the card is allowed its full 600 W. The block size of the drafter decides most of that, and the right block size changes with load. That is the part worth the read.
Why a Dense 65B Is the Hard Case
Picture a restaurant kitchen. A mixture-of-experts model is a brigade of five hundred cooks where each ticket is handed to ten of them. A dense model is a kitchen of sixty-five where every cook touches every plate. The second kitchen is smaller, cheaper to house and easier to reason about. It is also slower per plate, by construction, because nobody is ever idle and nobody can be skipped.
On a GPU the cooks are weights and the pass is the memory bus. This checkpoint keeps its attention layers in BF16 and quantizes the MLP layers to NVFP4, which lands at 61.55 GiB on the card. Producing one token means reading all of it. The card’s memory is rated at roughly 1.8 TB/s, so the ceiling for one stream is about 27 tokens per second before any kernel does any work. We measured 22.7. Plain decoding is already running at more than 80% of what the bus allows, and no flag is going to find the rest.
That is why speculative decoding matters more here than on any sparse model. It does not make the read cheaper. It makes each read pay for more than one token: a small drafter guesses a block ahead, the big model checks the whole block in a single pass, and everything up to the first wrong guess is kept. We covered the mechanics in the DFlash 2 field note on a 27B model. Ripple has no multi-token prediction head of its own, so the drafter is the only speculation it gets. Ricursive ships one alongside the model: 4.04B parameters in BF16, five layers, trained to draft blocks of 16 tokens.
The Rig
| Item | Value |
|---|---|
| GPU | NVIDIA RTX PRO 6000 Blackwell Server Edition, 96 GB, passively cooled, two chassis blowers |
| Host | AMD EPYC 8124P, Ubuntu 26.04, driver 615.71.09, CUDA 13.2 |
| Target | ricursiveAI/Ripple-65B-Preview-NVFP4, 61.55 GiB on the card |
| Drafter | ricursiveAI/Ripple-65B-Preview-DFlash2, 4.04B, BF16 |
| Engine | vLLM 0.33.0rc1 development build with Ripple support, FlashInfer NVFP4 kernels |
| Workloads | 512-token essays at 1, 8 and 32 streams; the first 200 GSM8K problems at 16 streams; HumanEval prompts; long-form prose in English and Portuguese |
| Power | Every cell at a 300 W cap, then again at 600 W, board power logged each second |
Greedy decoding unless stated, and every request stops where the model stops. No forced output lengths. We tried three block sizes, written here the way the drafter counts them: block 4, block 8 and block 16, which is 3, 7 and 15 drafted tokens plus the one the target adds itself.
The Server Edition is the passive card. It has no fans of its own and expects the chassis to move the air, so the 600 W cells ran with both blowers at full duty, one cell at a time, with an abort at 85 C that never fired. The hottest reading of the whole window was 77 C.
Block Size Is a Bet on the Text

For one user, any block from 8 up is worth 2.4x on prose: 55.6 tokens per second against 22.7. Block 16 adds nothing over block 8 there, 55.9, and the reason is in the acceptance numbers. On essays the target keeps about 2.8 tokens per step no matter how many the drafter offers. Prose is hard to guess, and the ninth through sixteenth guesses are almost never right.

Structured text is a different animal. On GSM8K the same drafter lands 5.0 tokens per step at block 8 and 6.2 at block 16. On code it is 4.7 and 5.5, and single-stream code generation goes from 22.3 tokens per second to 87.5 at block 8 and 101.3 at block 16. That is 4.5x on a dense 65B, on one card, at 300 W. The 200 math problems that take plain decoding 407 seconds finish in 118 to 125.
Then the load arrives. Every drafted token is a position the target has to verify whether it is right or wrong, and at 32 streams the target has no spare passes to give. Block 16 on prose drops to 479 tokens per second, 13% below running with no drafter at all. Block 8 holds at 737. Block 4, the weakest setting for a single user, is the best at 32 streams with 871.
None of the three is the answer. So the recipe does not pick one: vLLM accepts a schedule that sets the draft length from the number of requests running, and we gave it block 8 up to 16 running requests and block 4 above that. One server, 53.7 tokens per second for one user, 333.5 at 8 streams, 833 at 32, and within noise of the best fixed setting in every cell we measured.
export VLLM_DISABLE_COMPILE_CACHE=1 # see the caveats: the cache ignores the draft length
vllm serve ricursiveAI/Ripple-65B-Preview-NVFP4 \
--gpu-memory-utilization 0.92 --max-model-len 131072 --max-num-seqs 32 \
--reasoning-parser ripple --enable-auto-tool-choice --tool-call-parser ripple \
--enable-prefix-caching --enable-chunked-prefill \
--speculative-config '{"method":"dflash","model":"ricursiveAI/Ripple-65B-Preview-DFlash2",
"num_speculative_tokens":7,
"num_speculative_tokens_per_batch_size":[[1,16,7],[17,32,3]]}'
One note for anyone following the model card instead. The vendor’s serving recipe is SGLang at block 16, and it runs correctly on this card with stock SGLang 0.5.19 and the plugin files shipped in the model repository. It is not the fast configuration here: 47.6 tokens per second for one user, 418 at 32 streams, and the drafter leaves SGLang a cache of 68,915 tokens, so a 79k-token prompt is refused. vLLM with the same drafter keeps 188,447 tokens of cache and took that prompt in 30 seconds.
300 W Against 600 W
This card ships with a 600 W limit and can be capped down to 300 W, which is where its workstation sibling lives permanently. We ran everything at both. At 300 W the Server Edition and the 300 W Max-Q card in the other host are the same machine for this purpose: the math run took 406.9 seconds on one and 409.5 on the other without a drafter, and 125.3 against 123.7 with it.

The second 300 W is a wider road. It does nothing for one car. A single stream, with or without the drafter, draws 365 to 382 W when it is allowed 600, and returns 0 to 5% more tokens for it, because one stream is waiting on the memory bus and the bus does not speed up with voltage. Plain decoding at 32 streams still only pulls 411 W and gains 9%.
The drafter changes that. Verifying eight positions per request across 32 requests is real arithmetic, and the card finally has something to spend the watts on: 520 W mean at 32 streams with the schedule, 833 tokens per second becoming 1,053, a 26% gain. The math run goes from 130 seconds to 91, and block 16 on the same run drew 551 W and peaked at 77 C. Prompt ingestion gains more than anything else, about 45%: 3,650 tokens per second becomes 5,300, and a 79k-token prompt takes 21 seconds instead of 30.
The price is efficiency. At 32 streams the recipe produces 2.78 tokens per joule at 300 W and 2.03 at 600 W. You buy 26% more throughput with 73% more power, and on a passive card you also buy the airflow to carry it away. For a box that serves one or two people most of the day, the 300 W cap costs almost nothing and is the right default. For a box that takes bursts of concurrent work, the cap is a throughput setting, and it should be raised on purpose, with the blowers, not left wherever the driver booted.

What a User Actually Gets
Benchmarks with greedy decoding flatter a drafter. The model card recommends sampling at temperature 1.0 and top-p 0.95, and sampling costs acceptance: essays drop from 2.8 accepted tokens to 2.4, math from 5.0 to 4.0. With the recipe at 300 W that is 45.4 tokens per second for one user instead of 53.7, 298 at 8 streams and 760 at 32. Plain decoding does not move.
On long-form writing, eight prompts in two languages with answers up to 3,000 tokens, each stream runs at 40.5 tokens per second against 22.2 without the drafter, and still 27.9 with sixteen people on the card. A ten-turn conversation kept its first token under 250 ms on every turn, with the prefix cache covering about 90% of the prompt by turn seven. An hour of single-user traffic went through with zero errors, 41 to 43 tokens per second in every ten-minute slice, and flat memory.
Ripple thinks before it answers, and there is no switch for it. About half of the output tokens in the prose runs were reasoning. A reader waiting on an essay experiences roughly half the measured speed as visible text, which is worth knowing before anyone quotes 40 tokens per second to a user.
Keep It Honest
This is one preview model, one card and one night. The math and code sets are small. GSM8K scores moved between 189 and 196 of 200 from run to run on every configuration, because the same thirteen problems sometimes loop until the token cap, so we do not claim an accuracy difference between any two arms, and that includes the 600 W ones. The quality numbers on the model card are the vendor’s and we did not reproduce them.
Three things in the drafter path are less clean than the theory. Greedy output with the drafter is not character-identical to greedy output without it: three of eight short answers matched exactly and the rest diverged within the first hundred characters, fluent either way. The card was nearly full, 96,743 of 97,887 MiB at peak, and we would lower the memory fraction before calling it production. And this vLLM build caches compiled graphs without accounting for the draft length, so changing the block size and restarting dies on a shape assertion until the cache is disabled or cleared. We lost an arm to that before we understood it.
The larger caveat is the one the architecture predicts. The mixture-of-experts model we serve on this same card writes prose several times faster than Ripple does with its best recipe, 3.6x for one user on the long-form set, because it reads a fraction of its weights per token. We have been through that trade before, in the M5 Ultra and RTX PRO 6000 comparison. Dense has to pay that back in what the tokens are worth. A drafter does not settle that question. It makes it affordable to ask: at 22 tokens per second nobody would run the comparison for long, and at 55, or 87 on code, on one card capped at 300 W, a 65B dense model is something a small team can live with for a month and judge on its work.
That is the bet Ricursive made, and the kitchen analogy holds to the end. Sixty-five cooks who all touch every plate will never match the ticket times of a brigade that sends ten. The drafter is the expediter who lines up the next few plates before the pass is clear. Whether the food is better is the only thing left to find out.
Sources
- Ricursive Intelligence, Ripple-65B launch post; model cards Ripple-65B-Preview-NVFP4 (architecture, comparison table, sampling defaults) and Ripple-65B-Preview-DFlash2 (drafter size, block 16, SGLang flags).
- DFlash: Jian Chen, Yesheng Liang, Zhijian Liu, Block Diffusion for Flash Speculative Decoding, arXiv 2602.06036.
- vLLM documentation, Speculative Decoding.
- All throughput, power, temperature and acceptance figures are from our own runs on 16 and 17 November 2026.