Even Beam 1.0’s compact NVFP4 checkpoint occupies approximately 280 GB. The Hugging Face deployment guide recommends four NVIDIA B200 GPUs for practical serving, leaving room for the memory needed by long contexts and concurrent requests.
Reflection released the downloadable weights on October 16, 2026. Beam is a text-only, 501-billion-parameter mixture-of-experts LLM built for coding, reasoning and agent workloads. It activates about 23 billion parameters per token, supports a million-token context window and ships under Apache 2.0.
Developers get substantial control over a large model without being tied to a closed API, provided they have the infrastructure to run it. Sparse computation reduces how much of the network runs for each token; it doesn’t eliminate the need to store the network. The weights and integration support are concrete release artifacts, while the published performance claims remain vendor-reported.
What Reflection Actually Released
The release centers on Beam-1.0-501B-A23B, with checkpoints in three formats:
- BF16: The higher-precision checkpoint, approximately 1 TB in safetensors format.
- FP8: A lower-precision option that the deployment guide directs teams toward when they lack Blackwell hardware.
- NVFP4: A roughly 280 GB checkpoint intended for NVIDIA Blackwell GPUs, with some parameters retained in BF16.
Apache-2.0 licensing gives builders a permissively licensed starting point for modification and redistribution, subject to the license’s terms. It does not mean the complete training data or every part of the original training pipeline is open.
Hugging Face documents day-one integration with Transformers, vLLM and SGLang, alongside supervised fine-tuning and reinforcement-learning recipes. Beam also ships with a dedicated Rust-based agent harness. Together, these give developers a documented route to serving the model, connecting tools and adapting it to a workload.
The sources describe different stages of availability. Reflection’s introducing-Beam announcement describes early access, with final evaluations underway and weights promised later that month. The October 16 Hugging Face post documents the downloadable release. They should not be treated as interchangeable launch records.
Why 23B Active Parameters Still Require Large GPU Memory
In Beam’s expert layers, the router selects eight experts from a pool of 256 for each token. That keeps the active parameter count around 23 billion, substantially below the total 501 billion parameters.
The other experts still need to be available. In the GPU-serving setup described by Hugging Face, all experts remain in memory even though only a subset performs computation for an individual token. The active parameter count therefore describes part of the computational workload, not the checkpoint’s memory footprint.
Nor does it establish that Beam will deliver the same latency or throughput as a dense 23B model. Routing, communication between GPUs, attention and serving configuration still matter.
The NVFP4 checkpoint reduces weight storage to approximately 280 GB. Hugging Face says two B200s, with 360 GB of combined memory in its stated configuration, can hold the weights. Its practical recommendation is four B200s, providing 720 GB and more room for activations, cached attention state and concurrent requests.
Four B200s are a serving recommendation, then, not a claim that the weights cannot fit on fewer GPUs. Fitting the checkpoint alone does not establish that the setup can operate a useful service.
Hardware generation also affects checkpoint choice. Blackwell runs NVFP4 natively, while older GPUs such as the H200 do not. Developers should choose a checkpoint that suits their accelerator support; the smallest download will not necessarily be the best deployment option.
The Million-Token Window Has Its Own Memory Budget
Beam’s long-context support uses a hybrid attention design. Of its 52 layers, 43 attend over a sliding window of 512 tokens, while nine attend to the full context.
That arrangement limits growth of the key-value cache, which stores attention state from previous tokens for reuse during generation. Hugging Face estimates that a full million-token sequence requires approximately 36.08 GiB of BF16 cache with the Transformers dynamic cache implementation. Its comparison estimates 208 GiB if all 52 layers instead retained the complete sequence.
These are per-sequence cache figures, separate from total serving memory. They apply to a specified implementation and are not a universal allocation guarantee across inference engines.
A service handling several long conversations must budget for more than one sequence’s state, alongside weights and other runtime allocations. Hybrid attention makes the advertised context length more manageable, but million-token requests still carry a memory cost.
Context capacity also needs to be separated from context quality. Supporting a million-token input does not, by itself, demonstrate reliable retrieval, reasoning or instruction following throughout that input. Those remain evaluation questions, particularly for agents carrying large repositories and accumulated tool outputs.
Agent Integration Requires More Than Tool Calling
Beam supports structured tool calling, configurable reasoning effort and reasoning that can remain in the conversation across turns. Hugging Face documents preserved reasoning through preserve_thinking.
Agent developers need to account for that when storing and replaying conversation history. An application that retains only the final user-visible answer may discard state the model expects to receive on the next turn.
The repository’s embedded chat template explicitly warns that dropping reasoning degrades output. It recommends setting allow_missing_thinking to false for serving, which makes a generation prompt raise an error when earlier assistant turns lack reasoning. This model-specific requirement is worth testing before placing Beam behind a generic chat gateway.
The launch documentation disagrees on reasoning defaults:
The Hugging Face blog describes five effort labels, from low through max, with medium as the default. The repository template additionally recognizes minimal and says an unset effort defaults to max.
Developers should set reasoning effort explicitly and verify behavior against the exact template and serving engine they deploy. An assumed default could change generation length and resource use.
Tool calling itself provides no security boundary. Applications still need to control tool permissions, isolate executable actions and decide which operations require approval.
The Benchmark Table Is Reflection’s, Not an Independent Test
Hugging Face explicitly attributes its precision-level benchmark comparison to Reflection. Selected reported results are:
Sources
- Hugging Face deployment guidehuggingface.co
- Beam-1.0-501B-A23Bhuggingface.co
- introducing-Beam announcementreflection.ai
- NVFP4 checkpointhuggingface.co
