Welcome Beam: a 501B open model you can own, customize, and scale

What it claims

Reflection's Beam-1.0-501B-A23B is an Apache 2.0, text-only MoE model for coding and agentic work. It has 501B total and 23B active parameters, a 1M-token context, and day-0 support in transformers, vLLM and SGLang. The deployment facts that matter:

• Memory: the BF16 checkpoint is about 1 TB. NVFP4 cuts it to about 280 GB.
• KV cache: it grows 36 KiB per token, against 208 KiB for full attention on all layers.
• Fine-tuning: LoRA SFT fits on one 8×B300 node.
• RL: full-parameter GRPO needs twelve 8×H200 nodes.

How it works

The page's architecture details beyond the summary:

• Attention layout: 52 layers with hidden size 5,120. 43 layers use sliding-window attention over 512 tokens with RoPE. 9 layers (every sixth, plus the last) are global and use no positional encoding.
• Global-layer query scaling: queries are scaled by (1 + (pos + 1) / 2048) ** 0.1, which the implementation calls "scalable-softmax query scaling".
• Attention internals: GQA with 48 query heads and 8 KV heads, QK RMSNorm, and a learned per-channel sigmoid output gate.
• MoE: the first 3 layers are dense SwiGLU. The other 49 each have 256 experts of about 39M parameters (intermediate size 2,560). Experts hold 98.4% of all parameters.
• Routing: sigmoid scores, 8 groups of 32, keep the top 4 groups, then pick the top 8 experts. There is no shared expert, and outputs are scaled by 2.5.
• Residual stream: at step k the sublayer output gets weight 1/√k and the existing stream gets √((k−1)/k). After 104 additions every contribution carries equal weight.
• Normalisation and precision: norms sit both before and after each sublayer. Logits pass through a tanh softcap at ±30. FP32 is pinned for the router, SwiGLU product, norms, RoPE, query scaling and softcap.
• Response template in the tokenizer: tokenizer.parse_response(...) splits reasoning, answer and tool calls into separate fields. Tool arguments use an XML-style grammar, so you must pass tools= to the parser for it to cast types (a bare 7 is otherwise ambiguous).
• Reasoning effort: low, medium (default), high, xhigh or max. preserve_thinking keeps reasoning in context across turns.

Evidence

• SFT language adherence: LoRA SFT for one epoch on Multilingual-Thinking. Beam then reasoned in the requested language on 16/16 held-out prompts, versus 3/16 for the base model. This measures language adherence only, not reasoning correctness.
• SFT throughput: about 19,000 tokens/s on 8×B300. The H100 equivalent takes four nodes.
• Triage demo: a Qwen3.5-0.8B decision model was built partly by Beam and then by GLM-5.3 after Beam's quota ran out. On 320 synthetic tickets it scored 76.25% all-three-correct, versus 4.69% for zero-shot prompting. Latency fell from 1,218 ms to 103 ms. This is evidence about the small model, not about Beam.
• Precision benchmarks: the per-precision benchmark table and the vibe-eval results are not in the page text, apart from footnotes.

How to use it

Hardware options stated on the page:

• NVFP4 (Blackwell only): 2×B200 holds the weights with little headroom, so plan for 4×B200. Also listed are 8×B200, 2×B300, 8×RTX Pro 6000, and SGLang on 4×B300.
• FP8: for pre-Blackwell GPUs. SGLang uses 8×H200.
• BF16: 16×H200, since 8 would leave each GPU 139 GB of its 141 GB.
• Device count: for expert parallelism it must divide 256.

transformers needs a recent version:

pip install -U "transformers>=5.20.1"

vLLM with BF16 and speculative decoding:

vllm serve reflection/Beam-1.0-501B-A23B \
  --tensor-parallel-size 16 \
  --speculative-config '{ "method": "dflash", "model": "reflection/dflash2-drafter-preview", "num_speculative_tokens": 15 }'

SGLang with NVFP4 on 4×B300:

python -m sglang.launch_server \
--model-path reflection/Beam-1.0-501B-A23B-NVFP4 \
--served-model-name beam \
--tp 4 \
--attention-backend trtllm_mha \
--page-size 64 \
--context-length 1048576 \
--mem-fraction-static 0.85 \
--enable-unified-memory \
--speculative-algorithm DFLASH \
--speculative-draft-model-path reflection/Beam-1.0-501B-A23B-DFlash2 \
--speculative-dflash-block-size 8 \
--tool-call-parser beam --reasoning-parser beam \
--host 0.0.0.0 --port 30000

For Hopper, the SGLang recipe changes three things: use -FP8, --tp 8, and --attention-backend fa3.

Serverless access goes through the HF router as reflection/Beam-1.0-501B-A23B:auto, served by Baseten, Fireworks and Together.

GRPO with Miles trains on DAPO-Math-17K and evaluates on AIME25:

• Full-parameter run: twelve 8×H200 nodes, each needing 2 TB of NVMe scratch for optimizer streaming.
• Batching: 32 prompts × 8 responses per step.
• Optimiser: Adam at a constant 1e-6, with no KL or entropy penalty.
• Off-policy lag: rollouts are one update behind training.
• LoRA variant: rank 16 on four 8×H200 nodes, with no NVMe offload.

flowchart LR
  S[SGLang rollouts<br/>32×8] --> R[Score boxed answer<br/>+ length penalty]
  R --> U[Megatron GRPO step]
  U -->|publish weights| S
  U -->|every 5 rollouts| E[AIME25 eval]
  U -->|every 20| C[Checkpoint]

Limits

• Drafter names conflict: vLLM uses reflection/dflash2-drafter-preview and SGLang uses reflection/Beam-1.0-501B-A23B-DFlash2. Check which one exists.
• B300 counts conflict: the sizing section says two B300s, while the SGLang recipe uses four.
• NVFP4 quality: the page says only that it "retains most" of BF16 quality.
• Vibe evals: the authors call them "not benchmarks", with one run per effort level. The ProgramBench plot is a post-hoc subset of 4 of 5 tasks (ripgrep was dropped).
• Demo provenance: the macOS demo source includes later Codex repairs, and the triage demo finished on GLM-5.3. Neither is Beam-only work.