FINAL-Bench / POCKET-Darwin-180B-GGUF

POCKET-Darwin-180B-GGUF

A 180B frontier model from a laptop to DGX Spark. A 4-bit GGUF build of Darwin-180B-RSI-R3 (111.3 GB, 4 files) for llama.cpp — runs on a gaming laptop with an 8 GB GPU and 32 GB RAM , a 128 GB mini PC , a CPU-only server, a single datacenter GPU, or NVIDIA DGX Spark .

• Quality kept: MMLU-Pro (2,000 questions, paired) 87.65% vs 87.65% for the BF16 original — difference +0.00 points, 95% CI [−0.95, +1.00] .
• Runs on a laptop: 4.17 tokens/s on an RTX 5060 Laptop GPU (8 GB) with 32 GB RAM.
• Runs without a GPU: 18–21 tokens/s on one server CPU socket, 78.8 GB peak RAM .
• Runs on a mini PC: any mini PC with 128 GB RAM holds the whole model in memory — no GPU needed.
• Shorter answers: on the same 2,000 questions, answers average 3,694 tokens vs 4,322 for the same-format parent build (−14.5%).

From an 8-GPU server to a laptop

At BF16 the original weighs 360 GB — more than four 80 GB H100s can hold, so in practice it is served on an 8-GPU H100 server; we ran it on 4× B200, and the original card recommends 8× B200. POCKET brings that class of model to a personal computer.

Darwin + POCKET in one picture

• Darwin (model-level RSI): built on Qwen3.8-Flash-Next (180B MoE, 512 routed experts). The model solves verifiable problems, keeps only its own checked-correct solutions and trains on them — no human-written answers. Only attention paths and shared experts are trained; the experts, router, per-layer n-gram embeddings and MTP head stay intact.
• POCKET (on-device): a graft onto the widely used UD-Q4_K_XL layout — exactly the 300 R3-changed tensors re-encoded in the layout's own format, every other byte identical; about 3B active parameters per token; experts read on demand from SSD via memory mapping.

What this is

Darwin-180B-RSI is Qwen3.8-Flash-Next improved by model-level recursive self-improvement (RSI) : the model solves verifiable problems, keeps only its own solutions that check out, and trains on them — no human-written solutions. R3 is the second round on top of R1.

Only 300 tensors changed between the parent and R3 (attention paths and shared experts; all 512 routed experts, the router, the per-layer n-gram embeddings and the MTP head are unchanged). So this build takes the widely used Unsloth UD-Q4_K_XL layout of the parent and replaces exactly those 300 tensors with R3's weights, encoded in the same format the layout uses for them (Q8_0). Every other byte is identical to the parent build.

Verified before release:

• all 300 target tensors found, same type and size, read back equal to R3 — 300/300
• conversion verified against the parent build: 570 untouched tensors byte-identical
• loads and runs in llama.cpp b11048

Quality — before vs after quantization

MMLU-Pro, 2,000 questions stratified by subject (fixed by question-id hash, never chosen by looking at results), 0-shot CoT, temperature 1.0, top-p 0.95, top-k 20, min-p 0, seed 7, up to 131K tokens. Paired bootstrap 95% CI on the same questions.

Zero truncated answers. 4-bit quantization costs nothing measurable.

The RSI gain carries over

Model-level RSI lifted R3 over R1 on held-out SuperGPQA by +1.03 points (95% CI [+0.05, +2.00], statistically significant) — 1,000 questions never used in training or selection. Because this build keeps every R3-changed tensor at 8-bit and matches R3 BF16 exactly on MMLU-Pro, it carries that gain to a single machine. See the R3 card .

Reference — the original Darwin-180B-RSI (BF16) benchmark results

POCKET carries the weights of the Darwin-180B-RSI line. For reference, these are the official results of the original BF16 model ( Darwin-180B-RSI ) — #1 on seven Hugging Face official leaderboards .

Head-to-head with frontier models (published scores):

Settings for the reference results: BF16, vLLM, temperature 1.0 · top-p 0.95 · top-k 20, up to 131,072 thinking tokens; voting as listed per benchmark (see the original card ).

Where it runs

Per token the model activates only about 3B parameters (10 of 512 experts). llama.cpp memory-maps the file, so the experts a token needs can be read straight from a fast SSD — the whole 111 GB does not have to fit in memory. More memory simply means more of the model stays resident and it runs faster.

Measured

Device classes and recommended specs

Peak RAM in the CPU run is below the file size because llama.cpp reads the per-layer n-gram embeddings from the file on demand.

Run

Requires llama.cpp b11048 or newer (architecture qwen4exp ).

# DGX Spark / single large GPU
llama-server -m POCKET-Darwin-180B-UD-Q4_K_XL-00001-of-00004.gguf -ngl 999 -fa on -c 131072 --jinja
# Laptop / desktop with 8 GB+ VRAM and 32 GB+ RAM (experts streamed from SSD)
llama-server -m POCKET-Darwin-180B-UD-Q4_K_XL-00001-of-00004.gguf -ngl 999 --cpu-moe -fa on -c 8192 --jinja
# CPU only
llama-server -m POCKET-Darwin-180B-UD-Q4_K_XL-00001-of-00004.gguf -ngl 0 -t 16 -c 8192 --jinja --load-mode none

Recommended sampling: temperature 1.0, top-p 0.95, top-k 20. It is a reasoning model — give it room (≥ 2,048 output tokens); the reasoning is returned in reasoning_content .

Text model (the vision encoder is left out to keep the build compact).

Coming next

• ZTC confidence signal for this build.
• DGX Spark throughput figures for this build.

Credits and license

• Base model: Qwen/Qwen3.8-Flash-Next by the Qwen team, Alibaba — Qwen Community License 1.0 (see LICENSE ).
• GGUF layout: unsloth/Qwen3.8-Flash-Next-GGUF (UD-Q4_K_XL).
• RSI training and this build: VIDRAFT (FINAL-Bench).