Reflection AI releases Beam, a 501B open-weight agent model

Reflection AI has released Beam, a sparse Mixture-of-Experts model built for coding, reasoning, and agent workflows. The company published the weights on Hugging Face under an Apache 2.0 license and opened the surrounding agent harness, serving integrations, and post-training recipes through an ecosystem of more than 40 partners, according to its release post.

Beam contains 501 billion parameters and activates 23 billion for each token. Mixture-of-Experts models route tokens through a subset of specialized parameter groups, reducing the arithmetic required during inference. Serving memory still tracks the full expert set, so Beam requires substantially more capacity than a dense 23B model.

501B total, 23B active

The Apache 2.0 license permits commercial use, modification, and redistribution subject to its license and notice requirements. Developers should also check the individual licenses attached to the harness, training tools, and third-party integrations.

Raw storage for 501B parameters is roughly 1TB in BF16, 500GB in FP8, or 250GB at four-bit precision before quantization metadata, runtime buffers, and the key-value cache. Actual hardware requirements depend on the artifact, context length, batch size, and serving runtime.

Everything included with the weights

Reflection is releasing deployment and customization components alongside the model:

• Weights in BF16, FP8, and NVFP4 formats.
• A speculative-decoding drafter model that proposes tokens for Beam to verify, potentially increasing generation speed.
• A reference implementation, tokenizer, and model card with final benchmark results.
• Mirror CLI, the open-source agent harness used during Beam’s training.
• Fine-tuning and reinforcement-learning recipes for NVIDIA NeMo RL, Hugging Face TRL, Anyscale SkyRL, Axolotl, and related tools.
• A first-party service through the API console, with free access at the start of its public beta.

Announced runtime support covers Hugging Face Transformers, vLLM through Inferact, SGLang through RadixArk, Unsloth, Axolotl, TokenSpeed from the LightSeek Foundation, and NVIDIA Dynamo. Lower-precision formats can reduce memory use and bandwidth demands, although quality, throughput, and hardware compatibility require testing on the intended deployment stack.

Dell and HPE offer private deployments for organizations that need Beam behind a firewall. A developer can run the Mirror client on a laptop and connect it to a remote endpoint, while self-hosting the complete model requires a multi-accelerator server or cluster. The private deployment option targets air-gapped, regulated, and sovereign environments that cannot send prompts or code to a shared API.

Benchmarks show the trade-offs

Reflection reports the following model-card results. Higher scores are better, and “NR” means the comparison model had no reported result in the supplied table.

Beam trails the listed competitors wherever the table provides a direct comparison. Reflection’s case for the model rests on inference efficiency and the completeness of its open deployment stack.

Reflection separately reports reasoning scores comparable to GLM-5.2 while using three to four times less inference compute. That comparison is distinct from the GLM 5.3 results in the table. Beam also exposes a reasoning-effort setting that adjusts the token budget, allowing users to trade additional inference work for higher accuracy.

Benchmark results can shift with the agent harness, tool permissions, reasoning budget, test-time retries, and scoring method. Sparse-model economics also depend on expert routing, accelerator interconnects, batch size, and quantization, so production latency and cost cannot be inferred from active parameter count alone.

Four weeks on thousands of GB300s

Reflection pretrained Beam on 23.8 trillion curated tokens drawn from the web and licensed proprietary datasets. The company says pretraining finished in under four weeks on 6,144 NVIDIA GB300 NVL72 GPUs, reaching 92.3% final goodput, the share of cluster time spent on useful training work.

Reflection’s largest post-training run generated more than 100 million reinforcement-learning rollouts on 10,500 NVIDIA GB300 GPUs over four weeks. A rollout records the model attempting a task, taking actions, receiving feedback, and producing data used for subsequent updates.

Policy staleness complicated the asynchronous training system because long-running rollouts could come from older checkpoints while newer weights were already being optimized. Reflection says it developed algorithms that kept learning stable when interactions were more than a day old and reduced differences between the training and inference environments.

The infrastructure operated at the following scale:

• An average of 110,000 concurrent rollouts during training.
• Up to 170,000 concurrent sandboxes and more than one billion sandbox-creation requests across the campaign.
• A median of about 12 seconds to distribute new weights to the inference fleet through a hierarchical RoCE and NVLink system.
• Seventy-one inference incidents handled without terminating the training job.
• Lost capacity below 0.02% of total GPU-minutes.

Mirror exposes the agent loop

Mirror provides the terminal interface and execution loop used to train and evaluate Beam. Developers can inspect the agent’s activity, approve tool calls, steer an active task, resume previous conversations, and run parallel agents in separate Git worktrees. Model Context Protocol support lets the harness connect to external tools and data sources.

A Python front end manages prompts, skills, and developer tooling, while a Rust core drives the model over a local connection. Reflection also uses that core for evaluation, reducing differences between its benchmark harness and the software developers run. Beam has been tested with Pi from Earendil, Hermes from Nous Research, and the OpenCode setup.

Specialization without a full RL run

Reflection is publishing fine-tuning and reinforcement-learning tooling derived from Beam’s post-training campaign, which used about 1.3 billion sandboxes across training, evaluation, and ablation studies. The company is also adopting OpenEnv as an environment standard for future runs.

Teams with narrower workloads can use the supplied self-distillation process:

1. Generate Beam traces for representative tasks.
2. Verify successful traces with tests, rewards, or other task-specific checks.
3. Train a LoRA adapter on the verified examples.
4. Repeat the process to improve success rates and reduce token use.

This approach lowers the compute requirement for domain adaptation because it updates a compact adapter and reuses verified model behavior. Full reinforcement learning remains available for teams that need custom environments, rewards, or tool-use policies.

A broad launch footprint

Beam launches with distribution, hosting, and tooling support across major cloud and developer platforms. Named partners include:

• Cloud and infrastructure: Amazon Web Services, Applied Compute, CoreWeave, Google Cloud, Microsoft Azure, Nscale, Nebius, and Oracle.
• Inference and developer platforms: Baseten, Cloudflare, Databricks, Fireworks AI, Modal, NVIDIA NIM, OpenRouter, Together AI, and Vercel.
• Local and agent tooling: Hermes, LM Studio, Ollama, OpenCode, and Weights & Biases.

What developers should measure

Teams assessing Beam should compare end-to-end task economics under a fixed harness and tool policy. Useful measurements include:

• Success rate on representative repositories, languages, and task lengths.
• Cost per accepted patch or completed task, including retries and verification.
• Input and output token use at each reasoning-effort setting.
• Time to first token, total task latency, throughput, and concurrent-user capacity.
• GPU memory and storage requirements for BF16, FP8, and NVFP4 deployments.
• Recovery from tool failures, malformed output, interrupted sessions, and long-running tasks.
• Data-governance, licensing, and security requirements for API and private deployments.

Beam combines downloadable weights, multiple serving formats, an inspectable agent harness, post-training recipes, and broad deployment support. Its 23B active-parameter profile could improve cost per completed task when the model’s quality is sufficient for a given workload, while the 501B total footprint makes infrastructure planning and workload-specific testing essential.