Reflection Releases Beam: a 501B Open-Weight Coding Model With 1M Context

The weights arrived on October 16 after an October 5 preview

Reflection introduced Beam on October 5, 2026, but that first announcement explicitly said the model was still undergoing final red-teaming and that weights, a model card, a technical report and developer artifacts would be released later in the month. On October 16, Hugging Face published the implementation guide and Reflection’s public repositories exposed the BF16, FP8 and NVFP4 artifacts. This is therefore a release of usable model artifacts, not a rebranding of a future promise.

The canonical BF16 identifier is reflection/Beam-1.0-501B-A23B. At review time it was public and ungated at commit 78f8f654d40a40919b8e9954b40dd879ecb9a692. The companion identifiers are reflection/Beam-1.0-501B-A23B-FP8 and reflection/Beam-1.0-501B-A23B-NVFP4. A public repository proves inspectable availability; it does not prove that a team has downloaded the shards, secured suitable capacity or validated production behavior.

Beam activates 23B parameters but stores a 501B model

The model card lists 501.3B total parameters and 23.4B active parameters. Beam has 52 decoder layers: three dense layers and 49 mixture-of-experts layers. Each MoE layer contains 256 experts and routes every token to eight. Hugging Face says 98.4% of the parameters sit in those experts. The architecture reduces per-token compute relative to a dense 501B model, but every expert must still be available in memory.

That distinction controls deployment planning. Hugging Face describes the BF16 safetensors checkpoint as about 1 TB. It says NVFP4 reduces stored weights to roughly 280 GB by keeping most parameters at four-bit precision while retaining selected values in BF16. Sparse activation can improve throughput economics; it does not make download time, storage, sharding, startup, fault recovery or weight memory resemble a conventional 23B model.

The one-million-token context is a ceiling, not a reliability result

Beam accepts and produces text and advertises a 1,048,576-token context. Its hybrid attention uses 43 sliding-window layers over the previous 512 tokens and nine global-attention layers. Hugging Face estimates the BF16 key-value cache grows by about 36 KiB per token per sequence because only the global layers retain the entire sequence.

Neither a configuration limit nor a successful allocation establishes retrieval accuracy across a million tokens. Buyers should test evidence placed near the start, middle and end; conflicting files; repeated identifiers; stale documentation; tool outputs; and long multi-turn histories. Record prefill time, time to first token, memory, citation support and task completion at realistic lengths because “1M” is not an accuracy guarantee.

Apache 2.0 access is broad, while the evidence package is incomplete

The model repositories label Beam under Apache License 2.0, and the displayed license grants broad rights to use, modify and distribute subject to its notice and other terms. The model card says commercial and research use is intended and does not prohibit fine-tuning, quantization, merging or distillation. Organizations still need their normal legal, privacy, export and model-risk review; this article is not legal advice.

The model card provides training-data categories, benchmark tables and a safety summary, but it still marks the technical report as “coming.” Reflection says pretraining used 23.8 trillion tokens and that reinforcement learning generated more than 100 million rollouts on 10,500 GB300 GPUs over four weeks. Those scale statements, safety rates and all benchmark scores are vendor-reported. The available artifacts let independent teams begin testing; they do not independently validate the training or evaluation claims.

Three serving paths are available now

For self-hosting, Hugging Face documents Transformers, vLLM and SGLang. Its BF16 vLLM example uses tensor parallelism across 16 GPUs, described as two eight-H200 nodes. The SGLang recipes use NVFP4 on four B300 GPUs or FP8 on eight H200 GPUs, and the general hardware guidance recommends four B200s for practical NVFP4 capacity rather than assuming that two GPUs with just enough aggregate memory leave safe room for activations and cache.

For managed access, Hugging Face says its router can reach Beam through Baseten, Fireworks and Together. AWS says Beam is available in SageMaker JumpStart in US East (N. Virginia) and US East (Ohio), either as a managed real-time endpoint or through HyperPod Inference with JumpStart, SGLang or vLLM. Region, instance quota, cold-start behavior, endpoint retention and data handling must be verified for the chosen provider.

Vendor benchmark tables are a starting point, not a purchase decision

Reflection’s model card reports results across coding, terminal, reasoning and tool-use suites for BF16, FP8 and NVFP4. For example, it lists SWE-bench Verified at 81.6%, 80.2% and 80.7% respectively, and Terminal-Bench 2.1 at 80.1%, 78.9% and 78.4%. The card says evaluations used temperature 0.7 and top-p 0.99. AccessAllGPT did not reproduce those numbers, audit contamination controls or establish comparability with every external model result.

The close reported scores across precisions are relevant, but they do not prove that NVFP4 preserves quality on a particular codebase, language or tool harness. Run paired cases with identical repository state, prompts, tools, limits and graders. Track accepted patches, test regressions, unsupported claims, intervention rate, destructive actions, reasoning tokens, latency and total infrastructure cost.

Pricing remains provider- and infrastructure-specific

The reviewed sources do not publish one universal Beam token price. Public weights have no model-license fee under Apache 2.0, but operating them requires GPU instances, storage, transfer, caching, orchestration, monitoring and engineering. Hugging Face provider prices can differ by provider and route; SageMaker cost depends on instance type, Region, replica count and running time rather than a single model-wide rate.

Obtain a dated quote or measure a bounded deployment before comparing Beam with an API model. Include long-context prefill, generated reasoning tokens, speculative decoding, idle replicas, failed requests, endpoint startup, retries and human review. Cost per accepted coding task is more useful than nominal cost per token or active parameter count.

What builders should do next

Start with a hosted, low-authority trial if provider terms and data handling fit. Pin the exact model revision, choose one reasoning effort, disable destructive tools, cap context and output, and run a representative repository set with deterministic tests and human patch review. Use the public BF16 results only as a reference point, then compare the hosted or quantized route you can actually operate.

Advance to self-hosting only when control, customization or sustained utilization can justify the multi-GPU system. Wait if the missing technical report, provider price, Region, quota or capacity blocks diligence. Reject the deployment if measured quality, latency, cost, language coverage, safety behavior or infrastructure concentration fails the product contract. Open weights create options; they do not remove the need for an exit criterion.

Disclosures

AccessAllGPT received no weights, API access, credits, hardware, data, benchmark logs, private briefing, review, payment or compensation for this article. Reflection AI, Hugging Face, AWS and the named inference providers did not sponsor, review or endorse it. AccessAllGPT did not test, score or rank Beam. AccessAllGPT Research is operated by NeuralArc, is independent, and is not affiliated with Reflection AI, Hugging Face, AWS, Baseten, Fireworks or Together. Publication-wide relationships are listed on the disclosures page.