AtomicChat/Beam-1.0-501B-A23B-GGUF

Beam 1.0 501B-A23B · Atomic Dynamic GGUF

Atomic Dynamic (AD) quants of Reflection's Beam 1.0 with our own importance matrix, for machines with 160 to 256 GB of memory. Every file is measured side by side with the other GGUF builds of the same size on one stand, and this card shows where ours is better and where it is not.

---

The model is Reflection's, under the Apache License 2.0 (LICENSE in this repo).

Pick a file

File	Size on disk	KL divergence	top-1	For
AD-IQ3_XXS	197.1 GB	0.0192	96.13%	256 GB of memory
AD-Q2_K	186.8 GB	0.0210	95.90%	256 GB, with more room for context
AD-IQ2_M	164.8 GB	0.0337	94.90%	192 GB
AD-IQ2_XXS	133.8 GB	0.0674	92.82%	160 GB

KL divergence is how far the quantized model's predictions drift from the original BF16 weights; lower is better, zero means identical. top-1 is how often it picks the same next token the original would have picked.

The sizes are bytes on disk; the KV cache and compute buffers come on top and grow with the context. Beam keeps a full-attention cache in only 9 of its 52 layers (the rest use a 512-token sliding window), so the cache stays small: about 37 MB per 1,000 tokens at f16. On a Mac the GPU may use only part of the unified memory by default: raise the limit first (sudo sysctl iogpu.wired_limit_mb=...). We measured these files on NVIDIA GPUs and have not run them on a Mac.

How they compare

We downloaded Unsloth's files (the only other GGUF build of Beam on 16 October 2026) and measured them with the same reference logits, held-out text, context, chunk count and llama.cpp build as ours. Each of our files against Unsloth's file of the same size:

Ours	Size	KL divergence	top-1	Unsloth	Size	KL divergence	top-1
AD-IQ3_XXS	197.11 GB	0.0192	96.13%	UD-IQ3_XXS	197.15 GB	0.0189	96.13%
AD-Q2_K	186.83 GB	0.0210	95.90%	UD-Q2_K_XL	186.88 GB	0.0209	95.93%
AD-IQ2_M	164.81 GB	0.0337	94.90%	UD-IQ2_M	164.81 GB	0.0353	94.82%
AD-IQ2_XXS	133.79 GB	0.0674	92.82%	UD-IQ2_XXS	133.89 GB	0.0658	92.90%

Paired chunk by chunk over the 133 chunks of the held-out text (95% intervals from resampling the chunks):

• AD-IQ2_M: Unsloth's UD-IQ2_M drifts 4.8% more than ours (3.1% to 6.6%); ours matches the original's top token 0.08 points more often (0.01 to 0.15). Ours is 9 MB (0.006%) larger.
• AD-IQ3_XXS: ours drifts 1.6% more than UD-IQ3_XXS (the interval, -0.4% to 3.4%, includes no difference); top token the same within 0.1 points.
• AD-Q2_K: ours drifts 0.4% more than UD-Q2_K_XL (-1.6% to 2.3%): the same within the noise.
• AD-IQ2_XXS: ours drifts 2.5% more than UD-IQ2_XXS (-0.5% to 5.5%) and matches the top token 0.08 points less often: the same within the noise, with Unsloth's ahead on average.

At three of the four sizes the two builds are the same within what this measurement can tell apart, with Unsloth's slightly ahead on average; at IQ2_M ours is better. If you want the last fraction of a percent at 197, 187 or 134 GB, Unsloth's files are as good or a little better.

What is inside

Atomic Dynamic is how we decide which tensor gets which bits. The files use only standard llama.cpp quantization types.

• About 98% of the weights are the 256 routed experts of the 49 MoE layers (gate, up and down projections, 5120 x 2560 each). Only they are compressed hard.
• Each file starts from the per-layer types of the Unsloth file of its size (their layouts already give the first MoE layers' gate and up projections fewer bits) and is quantized with our importance matrix (below). On top of that, only moves that keep every layer in its precision regime:
  • the token embedding at q4_k (a lookup table: no importance matrix reaches it);
  • the output head at q8_0 (it writes the logits directly);
  • with the bytes left, the expert down projections of the layers with the most activation energy among those set below the file's main down type, one step up:
    • AD-IQ3_XXS: layer 6 at iq3_s;
    • AD-Q2_K: layer 3 at iq3_s;
    • AD-IQ2_M: layers 4 and 5 at iq2_s;
    • AD-IQ2_XXS: layer 3 at iq2_xs.
• These layout moves are small. A control at the IQ2_XXS size, Unsloth's exact types with our importance matrix, measured 0.0672 against our 0.0674: the moves are neutral, and where our files differ from Unsloth's it is the importance matrix.
• Every row length in this model is a multiple of 256, so no quantization type is swapped silently.

Running it

llama-server -m Beam-1.0-501B-A23B-AD-IQ2_M-00001-of-00004.gguf -ngl 99 -c 32768 --jinja

Point llama.cpp at the first part of a file; it loads the rest. The chat template is inside the file, and the recommended sampling (temperature 0.7, top-p 0.99) is stored in the file's metadata. Beam always reasons in its analysis channel; the budget is set with reasoning_effort (minimal, low, medium, high, xhigh, max; the template's default is max), for example --chat-template-kwargs '{"reasoning_effort": "medium"}'.

Needs llama.cpp with Beam support. On 16 October 2026 that support is the open pull request ggml-org/llama.cpp#30670 (not merged yet). We built and measured everything with its head commit 00d962b64756 (danielhanchen/llama.cpp, branch model-add-beam). Until it is merged, build that branch; when it lands, check this card for any change.

How we measured

• Reference: the BF16 weights in GGUF, run unquantized: our own conversion of Reflection's checkpoint (revision 78f8f654) with the converter of that pull request. Perplexity on the held-out text is 2.1216.
• Held-out text: eval_neutral from our calibration dataset (30 languages), never used for calibration. 133 chunks at 4096 context.
• Metric: per-token KL divergence of each file's predictions against the reference, plus top-1 agreement.
• Hardware: the BF16 reference and Unsloth's UD-Q2_K_XL and UD-IQ2_M on 8x A100-SXM4 40 GB; our files and Unsloth's UD-IQ3_XXS, UD-IQ2_XXS and UD-IQ2_M on 8x A100-SXM4 80 GB. UD-IQ2_M, measured on both, gave the same numbers to six digits.
• llama.cpp 00d962b64756, the same build for every file in the tables.

How the importance matrix was made

The matrix comes from 2.86M tokens of our calibration corpus (agentic and tool use, code, reasoning, many languages, long documents, and a sweep over the vocabulary), every conversation rendered through this model's own chat template and read with --parse-special:

• 2.44M tokens at context 512, split over several machines;
• 0.42M tokens of 16k to 32k token documents at context 32768.

Unsloth's matrix for their files, by its own header, is 156 chunks of 2048 tokens (0.32M tokens); ours gives each of the 256 experts about 9x more tokens. That made a measurable difference at IQ2_M only.

It was collected on a Q8_0 copy of the model, not on the BF16 weights: the BF16 is 1.0 TB, more than the 320 GB of VRAM of most of the machines we had. Q8_0 activations are very close to the BF16 ones, but this is a proxy, and we say so. The Q8_0 was Unsloth's, made with the same converter; we checked tensor by tensor that it holds the same weights as our BF16 to within Q8_0's rounding.

Model details

Mixture of experts, 501B parameters in total and about 23B active per token: 52 layers (3 dense, then 49 MoE), hidden size 5120, gated grouped-query attention (48 query heads, 8 key-value heads, head size 128) with a 512-token sliding window in 43 layers and full attention without RoPE in 9, 256 experts with 8 active per token (sigmoid routing in 8 groups, 4 of them used), vocabulary 151,936. Reflection's config sets a maximum context of 1,048,576 tokens; we measured at 4096 and did not test long context.