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

Beam is focused on coding and agentic use cases. It is for teams that want a frontier-scale model on their own hardware, infrastructure, or cloud, and want to customize it to their own use cases. Beam ships with its own dedicated open source Rust based harness that delivers the best performance from the model.

Beam has a native transformers implementation, as well as downstream libraries like vLLM and SGLang. We’ve worked with the Reflection team to bring you inference, SFT (supervised fine tuning), and RL (reinforcement learning) recipes for you to build with this model for your needs. On top of day-0 support in transformers, SGLang and vLLM, this post shows you how to run it, how to post-train it, and what we built with it.

TL;DR

• 501B-parameter MoEs LLM with 23B active per token. 52 layers, 256 experts per MoE layer, 8 routed per token.
• Text in, text out with context window of 1M tokens.
• Checkpoint formats: BF16, FP8, and NVFP4
• Reasoning that can stay in context across turns (preserve_thinking), tool calling with a dedicated grammar. The model supports five reasoning values: "low", "medium" (default), "high", "xhigh", and "max".
• Response template in the tokenizer.
• Speculative decoding drafter model with DFlash2
• Day-0 libraries: transformers, SGLang, vLLM. Full-parameter RL with Miles.
• Ships with a Rust-based custom harness.
• Apache 2.0.

Build with Beam

Reflection is going to give out $10,000 Hub credits to the best projects that use Beam. All you have to do is make a thing, and share it on the Hub:

• You could make a demo that uses the Beam model on Spaces
• You could quantize it for your favorite hardware
• You could generate a synthetic dataset for your favorite problem
• You could build an RL environment with or for Beam
• You could benchmark Beam and share the results.
• You could surprise us!

If you build something with Beam, then share it on the Hub for a chance to win $10,000. All you have to do is build the space, model, or dataset repo and share it on the model’s repo page. We’ll collect all the links, select the best, and send out the credits to your Hub accounts.

What is Beam?

Beam is a text-only model built for long-context (1M context length) reasoning and agentic work. It is a sparse MoE model, where each token is computed by a small fraction of the network, so it runs at the speed of a much smaller model while keeping the capacity of a large one.

Attention

The decoder has 52 layers with a hidden size of 5,120. Most layers use sliding-window attention over the previous 512 tokens; every sixth layer, and the last one, attend to the full context. That gives 43 sliding-window layers and 9 global ones.

Inside the attention block (both layer types)

The two kinds of layers handle position differently. Sliding-window layers use RoPE, since relative position matters most within a short window. Global layers use no positional encoding. Instead, each query is multiplied by a scaler that grows slowly with the number of visible tokens, (1 + (pos + 1) / 2048) ** 0.1. It acts as a temperature: the softmax keeps its precision as the context lengthens instead of flattening out. The implementation calls this scalable-softmax query scaling.

Attention uses grouped-query attention with 48 query heads and 8 key-value heads, with RMSNorm on queries and keys. A learned sigmoid gate, computed from the layer input, scales every channel of every head before the output projection.

Mixture of Experts

The first 3 layers use a dense SwiGLU MLP. The other 49 replace it with a Mixture-of-Experts block of 256 experts, each a SwiGLU MLP with an intermediate size of 2,560, or about 39M parameters. The experts hold 98.4% of the model's parameters.

The router follows DeepSeek-V3's group-limited scheme. It scores all 256 experts with a sigmoid, splits them into 8 groups of 32, keeps the 4 best groups (ranked by the sum of each group's top two scores), then picks the top 8 experts inside them. Beam uses the same group sizes as DeepSeek-V3 but no shared expert. Expert outputs are combined with normalized router weights and scaled by 2.5.

Only 8 experts run per token, so the model computes each token with about 23B parameters. All 256 experts stay in memory, so deployment needs the memory of a 501B model but runs at the speed of a 23B one. The BF16 checkpoint is about 1 TB in safetensors format. The NVFP4 checkpoint stores most parameters in 4-bit precision for NVIDIA Blackwell GPUs, some parameters are kept in BF16 for accuracy. There are also FP8 checkpoints on the hub which are ideal for Hopper and Ampere series chips.

If you want to deploy Beam yourself, check out the vLLM or SGLang recipes below.

Residual Stream

The residual connections are the most distinctive part. A standard transformer adds each sublayer output to the stream with weight 1, so the stream grows with depth.

Beam counts the input embedding as step 1. At step k it adds the sublayer output with weight 1/sqrt(k) and keeps the existing stream with weight sqrt((k-1)/k). The squares of the two weights sum to one, so the stream stays at a constant scale from the first layer to the last. After all 104 additions, every sublayer output and the input embedding carry the same weight in the final hidden state.

Every sublayer is also normalized before and after, and the final logits pass through a tanh softcap at ±30, computed in FP32. The implementation fixes where it computes in FP32: the router, the SwiGLU product, the norms, RoPE, the query scaling and the softcap.

Long Context

Hybrid attention works well for long contexts. Each layer caches 2 x 8 KV heads x 128 dims = 2,048 values per token. If all 52 layers kept every token, the cache would grow by 208 KiB per token. Only the 9 global layers keep the whole sequence. The 43 sliding-window layers hold a fixed 512-token window each and stop growing. So the cache grows by 36 KiB per token, roughly a sixth of the naive rate.

Context

If all 52 layers were global

Beam

32K tokens

6.5 GiB

1.2 GiB

128K tokens

26 GiB

4.6 GiB

Full context (1M)

208 GiB

These numbers are per sequence, in BF16, with the transformers dynamic cache.

Benchmark Results

Here are the benchmark results across different precision levels, as provided by the Reflection team.

DeepSWE v1.1

43.3%

43.0%

42.7%

SWE Bench Pro v2-Hard

76.5%

78.4%

78.6%

SWE Bench Pro v1

66.1%

65.9%

65.6%

Terminal Bench v2.1

80.1%

78.9%

78.2%

SWE Atlas Codebase QnA

31.8%

32.2%

31.4%

SWEBench Multilingual

78.3%

78.1%

77.5%

SWEBench Verified

81.6%

80.2%

80.7%

AIME 2026

97.7%

98.0%

97.5%

HLE (no tools)

36.0%

36.0%

34.8%

HLE (with tools)

51.1%

51.1%

51.1%

SciCode

49.2%

48.3%

46.9%

CriPT AA

16.3%

17.4%

15.4%

GPQA Diamond

90.6%

90.3%

89.3%

LiveCodeBench

88.3%

88.1%

87.4%

AutomationBench - public split only

39.3

38.2

39.8%

MCP Atlas

80.8%

81.5%

80.5%

Tau3 Banking

36.1%

36.8%

35.4%

BrowseComp w/ context management

76.8%

76.7%

75.6%

DeepSearchQA w/ context management

80.5%

79.6%

81.1%

AA-LCR

78.2%

79.4%

78.7%

LongBench v2

67.5%

67.6%

67.2%

IFBench

79.6%

80.7%

79.2%

AA Omniscience (index) - public split only

10.8

8.8

9.8

Hardware Requirements

The most practical way to serve the model is serving the NVFP4 checkpoint, which retains most of the quality of the bf16 checkpoint. NVFP4 stores some weights in 4 bits, and this way, it shrinks the 501B parameters in BF16 from 1 TB to ~280 GB. Blackwell GPUs run NVFP4 natively but GPUs older than Blackwell like the H200 can't. The FP8 checkpoints are suitable for GPUs older than Blackwell.

A B200 has 180 GB of HBM3e, so two of them (360 GB) can hold the Beam weights, with little room left for activations and the KV cache. Plan for four B200s (720 GB), which leaves plenty of room for long contexts and concurrent requests. You can also serve it on a full 8xB200 node, or on two B300s at 288 GB each, or even 8xRTX Pro 6000. If you don't have Blackwell hardware, use Inference Providers (serverless) to test Reflection.

Inference Support

Beam comes with day-0 support in transformers, SGLang and vLLM.

Transformers

Install the latest version of transformers.

pip install -U

The easiest way to run Beam is the text-generation pipeline:

transformers

pipeline pipe = pipeline(

, model=

, device_map=

) messages = [ {

:

,

:

} ] output = pipe(messages, max_new_tokens=

) output[

][

][-

]

The pipeline returns the whole chat. The last message is Beam's reply, already parsed by the response template.

Going one level lower, use AutoModelForCausalLM and AutoTokenizer.

transformers

AutoModelForCausalLM, AutoTokenizer model_id =

tokenizer = AutoTokenizer.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained( model_id, dtype=

, device_map=

)

Chat

messages = [ {

:

,

:

}, {

:

,

:

}, ] inputs = tokenizer.apply_chat_template( messages, add_generation_prompt=

, tokenize=

, return_dict=

, return_tensors=

, reasoning_effort=

Source: https://huggingface.co/blog/reflection-beam