Reflection releases Beam, an open 501B model under Apache 2.0

What's going on

Reflection, a new US AI lab, released its first model on October 16, 2026: Beam. The weights are freely downloadable on Hugging Face under the Apache 2.0 license, which allows commercial use and custom modifications. Beam is a text model (text in, text out) aimed at programming, reasoning (step-by-step thinking) and long-running agent tasks, where the model uses tools over many steps. It targets teams that want to run and customize a frontier-scale model on their own hardware, infrastructure or cloud. It comes with its own open-source harness written in Rust (the software wrapper that drives the model as an agent).

Architecture: big in memory, fast in operation

Beam is a Mixture-of-Experts (MoE) model. The network consists of many specialized "experts," and only a small share of them compute for each token. Here there are 256 experts per MoE layer, 8 of which are active per token. Of 501B parameters (the knobs learned during training), only about 23B are used per token. So the model runs at roughly the speed of a 23B model, but needs the memory of a 501B model because all experts must be loaded.

More key specs, according to Hugging Face: - 52 layers, hidden size 5,120; the first 3 layers are dense MLPs, the remaining 49 are MoE layers. Experts account for 98.4% of the parameters. - The router follows DeepSeek-V3's group-limited scheme (8 groups of 32 experts, the best 4 groups, then the top 8), but without a shared expert. - Attention (the mechanism the model uses to relate parts of the text) is hybrid: 43 layers look only at the last 512 tokens (sliding window), while 9 layers look at the full context. Sliding-window layers use RoPE for positional encoding. The global layers use none, but apply a query scaling that grows slowly with context length. - It uses grouped-query attention with 48 query heads and 8 key-value heads, plus a learned sigmoid gate. - The residual connections are unusual: each contribution is weighted (1/√k) so the data stream stays the same size across all layers. Output logits are capped with a tanh softcap at ±30.

The hybrid approach saves a lot of memory in the KV cache (the buffer the model builds for text it has already read). It grows by only 36 KiB per token instead of 208 KiB. At 1M tokens, that's 36.08 GiB instead of 208 GiB per sequence (BF16, default transformers cache).

Beam supports reasoning that can persist in context across multiple conversation turns (preserve_thinking), tool calling with its own grammar, and five reasoning levels: low, medium (default), high, xhigh and max. A chat template in the tokenizer automatically separates the thinking process, the answer and tool calls.

Benchmarks (vendor claims)

The following numbers come from the Reflection team and have not been independently verified. Notably, the quantized variants mostly land just below BF16.

Other scores: DeepSWE v1.1 43.3%, LongBench v2 67.5%, HLE without tools 36.0%.

Hugging Face adds five of its own "vibe evals" (explicitly not benchmarks): multi-step tool calling, long-context code retrieval, a terminal task, AIME-style math and structured JSON output. At high reasoning, all five were correct. At low reasoning, the math task returned the right answer without the requested explanation, and the long-context answer was correct in substance but didn't match the expected format.

What you need to try it

Beam doesn't run locally on a home PC. The weights are huge: about 1 TB for BF16 and about 280 GB for NVFP4. NVFP4 runs natively only on NVIDIA Blackwell GPUs. For older cards (Hopper, Ampere), there are FP8 checkpoints.

• Recommended: four B200s (180 GB each, 720 GB total). Two B200s fit the weights but leave hardly any room for the KV cache.
• Alternatives: an 8×B200 node, two B300s (288 GB each), 8× RTX Pro 6000, or with SGLang four B300s with NVFP4 or eight H200s with FP8.
• BF16 with vLLM: 16 GPUs (two 8×H200 nodes).
• Without your own hardware: Hugging Face Inference Providers (Baseten, Fireworks, Together), Inference Endpoints with one click, or Ollama Cloud (ollama run beam:cloud, free for a limited time, with zero data retention according to Ollama). Through Ollama you can also launch Claude Code, Codex or OpenCode with Beam.

You need transformers>=5.20.1. For faster generation, there's a drafter for speculative decoding (DFlash2, up to 15 tokens of lookahead).

Customizing: SFT and reinforcement learning

Hugging Face provides recipes for post-training.

SFT with TRL and LoRA: LoRA trains only small add-on weights (adapters) while the base model stays frozen. On a node with 8 B300s, you can reach about 19,000 tokens/s. With H100s you need four nodes. After one epoch on Multilingual-Thinking, Beam thought in the requested language on 16 of 16 test prompts, versus 3 of 16 for the base model. That measures language fidelity, not the correctness of the reasoning.

GRPO with Miles: Reflection and RadixArk built a reinforcement learning (learning by reward) recipe. Full-parameter GRPO needs 96 H200s (64 for training, 32 for rollouts) or 64 H200s shared, and the LoRA variant needs 32 H200s. Each trainer node needs 2 TB of local NVMe storage for the optimizer state.

Demos and competition

Hugging Face showed several projects: a native macOS dictation app ("BeamSpeak," using Parakeet via MLX, built with Beam in the Pi coding harness), a multi-agent comparison on ProgramBench, and a fine-tuned decision model (Qwen3.5-0.8B) for incident triage. The latter got all three decisions right on 76.25% of 320 synthetic tickets, compared with 4.69% for zero-shot prompting, at roughly twelve times lower latency (102.58 ms versus 1,218.06 ms). Reflection is also awarding $10,000 in Hub credits to the best community projects.

Our take

An open model of this size under Apache 2.0 is rare, especially from a US lab. That's interesting for companies with their own GPU infrastructure, because they can keep data in-house and fine-tune the model. For individuals, Beam is practically usable only through cloud access. The caveats: all benchmarks come from Reflection itself, and the Hugging Face post is a partner release with a day-0 collaboration. Independent comparisons with other open frontier models are still pending. The vibe evals are only small samples. Notably, FP8 and NVFP4 lose very little quality according to vendor numbers, which makes running the model considerably cheaper.