Beam LLM Ships 501B Open Weights With a 1M-Token Context | Zeniteq
Loading
Loading article
Zeniteq is now available on mobile for iPhone, iPad and Apple Watch.Download nowLearn more
Beam LLM Ships 501B Open Weights With a 1M-Token Context
Reflection’s Apache-2.0 release includes deployment and post-training support, but practical serving calls for four NVIDIA B200 GPUs, according to Hugging Face.
Reflection released Beam, a 501-billion-parameter open-weights language model with a million-token context window, on October 16 under Apache 2.0 licensing. The mixture-of-experts model activates approximately 23 billion parameters per token and is optimized for coding, reasoning and agent workloads.
Hugging Face recommends four NVIDIA B200 GPUs for practical serving, with the compact NVFP4 checkpoint occupying roughly 280 GB. The release includes integration with Transformers, vLLM and SGLang, plus supervised fine-tuning and reinforcement-learning recipes, though performance claims remain vendor-reported and unverified by independent testing.
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
SWE-bench Verified concerns software-repair tasks, Terminal Bench evaluates work in terminal environments, and LongBench v2 addresses long-context understanding. They probe different capabilities and should not be collapsed into a single measure of agent reliability.
Reflection’s reported results suggest that NVFP4 retains much of BF16’s measured quality on these tests. They do not establish equivalent behavior on every workload. Publication by Hugging Face also does not make them independently reproduced evaluations.
There are different score sets in the sources. Reflection’s introduction lists 80.9% on SWE-bench Verified, while the Hugging Face release table lists 81.6% for BF16. The cited material does not establish enough about the relationship between those runs to explain the difference confidently. Comparisons should keep checkpoint, harness and evaluation conditions attached to the relevant result.
Reflection’s inference-efficiency estimate uses active parameters and generated token counts to approximate generation compute. The company explicitly excludes prompt prefill, context-dependent attention operations and serving overhead.
That estimate can inform an architectural comparison. It does not provide a measured cloud bill, end-to-end latency result or production throughput guarantee, especially for the long-context workloads Beam is designed to handle.
Hosted Availability Is Less Clear Than the Weight Release
The launch materials disagree on hosted access. Hugging Face’s blog points readers toward Inference Providers, while the model card’s provider status says the model is not deployed by a provider. That leaves a launch-time discrepancy rather than a confirmed serverless route. For an immediate deployment decision, the downloadable checkpoints and documented self-hosting paths are the firmer evidence.
Beam gives teams with substantial GPU resources a permissively licensed model they can inspect, adapt and run under their own operational controls. Teams considering a move from a closed coding API still need workload-matched tests: completed-task quality, latency, concurrent capacity and the cost of preserving long agent histories.
The release makes that evaluation possible. Whether operating a 280 GB checkpoint is the better bargain remains an open question.