Beam (Reflection)

Beam (released as Beam 1.0, model identifier Beam-1.0-501B-A23B) is a text-only large language model developed by Reflection AI for coding, reasoning and agentic tasks. It is a sparse mixture-of-experts model with about 501 billion total parameters, of which about 23 billion are active per token.^[1][10] Reflection announced Beam on October 5, 2026, as a selective preview, and released the open weights on Hugging Face on October 16, 2026, under the Apache License 2.0.^[1][9] The release included BF16, FP8 and NVFP4 checkpoints, a DFlash2 speculative decoding drafter, a tokenizer and reference implementation, a safety technical report, and Mirror CLI, the open-source coding harness Reflection says it built and trained Beam on.^[9][13] Reflection describes Beam as its first open-weight model and the first in a series.^[1][9] On release day, the vLLM project published day-zero serving support built with Inferact and NVIDIA, and the SkyRL team announced day-zero support for reinforcement-learning fine-tuning.^[24][26][28]

Release history

Preview (October 5-15, 2026)

On October 5, 2026, Reflection published "Introducing Beam: Reflection's 501B open-weight model". The post said Beam was undergoing final red-teaming and evaluations, offered early access through a waitlist, and said the weights, technical report, model card and developer artifacts would follow later in October, with the weights under Apache 2.0.^[1] On October 8, Reflection added a note to the post saying it had updated Beam's benchmark results.^[1]

During the preview, the developer documentation listed the API model as Beam-501B-A23B with a 256K-token beta context window (prompt and output combined) and a 128K-token maximum output, and warned that the context window might change during the beta.^[2]

Open-weight release (October 16, 2026)

On October 16, 2026, Reflection published "Beam is now available" and released the weights on Hugging Face under Apache 2.0.^[9] Its announcement on X said the release included weights, the tokenizer and a reference implementation; BF16, FP8 and NVFP4 weights and a DFlash2 drafter; and Mirror CLI, "the open source harness we built and trained Beam on". It described the launch as being "in collaboration with an ecosystem of 40+ partners".^[13]

The Hugging Face collection "Beam 1.0" contains four repositories:^{[10][11][16][17]}

Reflection's model card lists the release as instruction-tuned only; no separate base-model checkpoint is listed in the collection.^[10] At release, the model card still listed the technical report as "coming", while Reflection published a separate Beam Safety Technical Report.^[10][12]

Reflection's release post calls the surrounding stack "an open operating system for agents", in which "the model is the kernel" and the agent integrations, deployment containers, inference integrations and customization pipelines above the infrastructure layer are open.^[9]

Architecture and specifications

The Hugging Face model card gives these specifications:^[10]

Reflection's launch post describes the design as combining interleaved local and global attention, fine-grained routed experts, a controlled residual stream and several forms of load balancing.^[1] For the residual stream it describes a depth-based scaling approach, combined with SandwichNorm, elementwise attention gating and FP32 residual accumulation, to keep activation growth and outliers in check. Reflection says residual-stream RMS stayed bounded across all 52 layers during pretraining.^[1]

Layer details

Implementation write-ups from the vLLM and SkyRL teams describe Beam's layers in more detail than the model card:^[24][26]

Because only the 9 full-attention layers keep keys and values for the whole sequence, vLLM puts Beam's KV cache at 36 KiB per token in BF16 and 18 KiB in FP8, or about 18 GiB of FP8 cache for a full 1M-token context before sharding.^[24]

Expert routing

Beam's expert balancing builds on auxiliary-loss-free balancing, with cosine-decayed expert-bias updates.^[1] Reflection also uses sequence-level balancing and reports that the busiest expert's load, averaged across MoE layers, reached 1.04x at the end of pretraining, which it describes as near-uniform utilization.^[1]

The preceding DeepSeek-V3 method adds an adjustable bias to each expert's routing score. Recent loads determine bias updates; the bias changes expert selection, rather than the value that weights an expert's output.^[8] vLLM's write-up says Beam routes tokens the same way as DeepSeek-V3 but, unlike DeepSeek-V3, has no shared expert.^[24]

Chat format

Beam reads and writes "Beam Harmony", which builds on OpenAI Harmony, the format used by gpt-oss. Reflection's documentation lists these differences:^[21]

Reflection says it chose XML arguments because JSON escaping interacts poorly with code inside tool arguments, and that Beam was trained to reason on every turn, so each assistant turn starts with a non-empty analysis message.^[21]

Training

Pretraining

Reflection reports pretraining Beam on 23.8 trillion tokens drawn from the web, public sources and proprietary licensed datasets.^[1] The model card says the corpus includes general web content, source code, technical documentation, reference material, and educational and scientific documents, and that processing included quality filtering, exact and approximate deduplication, and benchmark decontamination.^[10] According to Reflection, about 95% of raw internet tokens were removed through parsing, deduplication and curation, and an OCR pipeline built on a vision-language model converted PDF material into training text.^[1]

Reflection says Beam was pretrained end to end in under four weeks on a cluster of 6,144 NVIDIA GB300 NVL72 GPUs, with nine semi-automatic rewinds caused by gradient-norm spikes or suspected silent data corruption, and goodput reaching 92.3% toward the end of the run.^[1] A midtraining stage extended Beam's effective context length to 1M tokens.^[1]

Reinforcement learning

Reflection reports a four-week reinforcement-learning run using 10,500 NVIDIA GB300 GPUs and more than 100 million rollouts.^[1] Its launch post adds the following details, all reported by Reflection:^[1]

Beam was trained with asynchronous policy gradients. Reflection says it developed new algorithms to keep learning stable when rollouts mix tokens from many model checkpoints, and to reduce numerical mismatch between the training and inference engines.^[1] It also trained with a controllable length penalty; the reasoning-effort setting exposed in the API lets users trade answer quality against token use.^[1] Reflection reports that browsing performance improved during an RL phase that contained no browsing tasks.^[1]

For the open release, Reflection said its largest RL runs used roughly 1.3 billion sandboxes across training, evaluation and ablations, and that its sandbox fleet peaked at 883,006 vCPUs across 23 clusters on Google Cloud and AWS.^[9]

Alignment

Reflection trained a second model from the pretrained checkpoint with a separate SFT and RL pipeline aimed at safety and alignment, then merged the RL teacher and the safety teacher through multi-teacher on-policy distillation (MOPD).^[1][12] Safety SFT followed the deliberative-alignment approach of Guan et al. (2024): traces are generated with the safety policy in the system prompt, filtered by an LLM judge, rewritten, and then trained without the policy in context.^[12] The safety report says safety data made up 1.62% of the alignment teacher's SFT dataset and that the safety RL environment held a fixed 5% weight in that teacher's RL mixture, with a 1:5 harmless-to-harmful task ratio.^[12]

Vendor-reported evaluation

All figures below were reported by Reflection, not measured independently. The model card's numbers (evaluated at temperature 0.7, top-p 0.99) supersede the earlier launch-post figures in several places; for example, SWE-bench Verified is 80.9 in the launch post but 81.6% for the BF16 checkpoint on the model card.^[1][10]

In the launch post, Reflection compared Beam with Inkling, Nemotron 3 Ultra, GLM-5.2, GLM-5.3, Kimi K3, Qwen 3.8 Max and DeepSeek V4.1 Flash. It said Beam is competitive with larger open models such as GLM-5.2 and approaches Qwen 3.8-Max on coding and agentic tasks, while conceding that "frontier open models like Kimi K3 remain ahead on raw capability".^[1] Reflection's central claim is inference efficiency: it says Beam reaches scores comparable to GLM-5.2 on advanced reasoning benchmarks with 3-4x less inference compute, and the model card says it reaches comparable quality to leading open models with about 3x fewer reasoning tokens.^[1][10]

Reflection estimates generation compute as 2 × active parameters × mean generated tokens per attempt, including reasoning and answers. The estimate excludes prompt prefill, context-dependent attention and serving overhead. It is an approximate compute comparison, not measured inference cost.^[1]

Independent evaluation

Artificial Analysis lists Beam 1.0 with a score of 30 on its Intelligence Index (version 4.3.2), ranking it 19th of 120 models, against a median of 19 for comparable models. It reports that Beam generated 79 million output tokens while running the index, compared with a median of 130 million, ranking 10th of 46 for verbosity. The same page lists a price of $1.30 per million input tokens and $4.30 per million output tokens, which it rates as expensive compared with open-weight models of similar size.^[23]

Inference and deployment

Self-hosting

Reflection's reference self-hosting setup is four NVIDIA B300 SXM GPUs connected by NVLink on a Linux amd64 host, using the NVFP4 checkpoint and the DFlash2 drafter.^[15] The documentation provides single-server guides for SGLang, vLLM and LightSeek's TokenSpeed, a Kubernetes Helm chart developed with Dell, scale-out guides for NVIDIA Dynamo, a Transformers cookbook, and a "Beam Verifier" tool for checking a deployment's correctness and comparing its performance to reference numbers.^[19][20] Reflection lists day-zero support in Transformers (Hugging Face), vLLM (Inferact), SGLang (RadixArk), Unsloth, Axolotl, TokenSpeed (LightSeek Foundation) and Dynamo (NVIDIA).^[9]

On the day of release, NVIDIA said on X that Beam was trained on NVIDIA GB300 NVL72 and "delivers over 70K tokens/sec/GPU on Blackwell Ultra out of the box on day 0". This is NVIDIA's own figure.^[14]

vLLM serving

The vLLM project published "Serving Reflection Beam on vLLM from Day 0" on October 16, 2026, credited to Inferact, Reflection and NVIDIA.^[24] The post says reasoning, tool calling and structured outputs work out of the box, and that the model can run with tensor, data or expert parallelism. Support shipped as a dedicated Docker image, vllm/vllm-openai:reflection-beam; vLLM's Beam recipe, updated October 16, says Beam support "has not shipped in a vLLM release yet".^[24][25] The beam reasoning and tool-call parsers read the response template that ships with the checkpoint, and by default vLLM constrains every response to that template so that tool calls always parse and match each tool's JSON schema. Setting VLLM_BEAM_ALWAYS_CONSTRAIN_OUTPUT=0 turns the constraint off.^[24][25] Served through vLLM, Beam reasons at the maximum effort, max (512), unless a request sets reasoning_effort.^[25]

The recipe lists these targets (sizes in decimal gigabytes; minimum GPU memory is the total across all GPUs, including 20% headroom over the weights):^[25]

On Blackwell GPUs the NVFP4 checkpoint runs W4A4; on Hopper GPUs, vLLM serves its FP4 experts through Marlin kernels with BF16 activations. The recipe says Beam's kernels, including a custom all-reduce used with expert parallelism, are CUDA-only.^[25]

Agent-driven kernel optimization

vLLM says its first Beam implementation was "an unoptimized, almost pure PyTorch version of the model", which coding agents then optimized autonomously by profiling the model, writing kernels and benchmarking each change.^[24] On TP8 on GB200, seven changes cut batch-1 decode from 8.95 ms to 3.30 ms per step (2.71x faster) and an 8 x 2,048-token prefill at about 100K context from 328 ms to 176 ms (1.87x). They included fusing the post-norm, scaled residual add and next pre-norm at each of the 104 sublayer boundaries into one Triton kernel, which vLLM credits with a 40% cut in decode time; running both tensor-parallel all-reduces inside the norm kernels, using FlashInfer's multicast all-reduce; packing the Q, K, V and gate projections into one GEMM; and adding Beam's 5120 x 256 shape to vLLM's small-batch FP32 router kernel. After the changes, one MoE layer runs as 13 kernels in batch-1 TP8 decode. Six were written, fused or extended for Beam; the other seven come from libraries, and vLLM says most of the remaining time is spent in them.^[24]

Reported throughput

All figures below are vLLM's own measurements:^[24]

Speculative decoding in vLLM

vLLM supports the DFlash2 drafter from day 0. It fuses the drafter's convolution, norms and KV writes, runs the whole draft step in a CUDA graph, and says FP8 KV cache works for the drafter with no change in acceptance.^[24] The recipe recommends 7 speculative tokens (the drafter supports up to 15) and says the drafter adds about 1.7 GB per GPU, which reduces KV-cache capacity.^[25] vLLM also offers adaptive verification for the drafter: with enable_adaptive_verification, it predicts how likely each draft token is to be accepted and verifies only the tokens worth their cost, instead of a fixed number per step. Because DFlash2 has no confidence head, the estimate comes from the drafter's own logits.^[24] vLLM's results on TP8, on the SPEED-Bench low-entropy category (about 1K-token prompts, mostly code completion and text sorting, greedy decoding, up to 4K output tokens):^[24]

At concurrency 128, vLLM says adaptive verification also cut p99 time per output token by 9%. It warns that low-entropy text is easier to predict, so acceptance will be lower on open-ended chat.^[24] These acceptance lengths come from a different benchmark than Reflection's own DFlash2 figures above.

Quantized checkpoints

Reflection says the NVFP4 checkpoint is about 3.4x smaller than the BF16 release (273 GiB versus 934 GiB), so a full copy fits on four B300 GPUs, and that native NVFP4 requires NVIDIA Blackwell GPUs.^[16] For the FP8 checkpoint, measured on an eight-GPU H200 endpoint with a BF16 KV cache, it reports mean GPU memory use per GPU falling from 135.08 GiB in BF16 to 88.40 GiB.^[17] Reflection credits four NVIDIA engineers with guidance on its quantization recipes.^[16]

DFlash2 drafter

The drafter uses DFlash2, a method from Inco AI that builds on DFlash, a block-diffusion speculative decoding method.^[11][18] It drafts a whole block of tokens in one forward pass, keeps the top candidates at each position, and uses a small selector to pick one path. It conditions on hidden states from five of Beam's layers (4, 16, 28, 40 and 46), reuses Beam's frozen embedding and LM head, and attends over a 4,096-token sliding window so drafting cost does not grow with context length.^[11] It has 1.93 billion parameters across 5 layers, was trained with a block size of 16, and is recommended for serving with a block size of 8. With rejection sampling, Beam verifies every drafted token and its output distribution is unchanged.^[11]

Reflection's figures, measured with Beam NVFP4 on four B300 GPUs with greedy decoding:^[11][18]

On replayed agentic coding traces from DeepSWE, the mean acceptance length was 4.82 overall, 5.72 for prompts under 2K tokens and 4.23 for prompts of 64K-128K tokens.^[11]

Hosted access

Reflection's announcement lists launch availability on Amazon Web Services, Nscale, Applied Compute, Baseten, Cloudflare, CoreWeave, Databricks, Fireworks AI, Google Cloud, Hermes, LM Studio, Microsoft Azure, Modal, Nebius, NVIDIA NIM, Ollama, OpenCode, OpenRouter, Oracle, Together AI, Vercel and Weights & Biases, with Dell and HPE delivering Beam for on-premises, sovereign and air-gapped environments.^[9] Reflection's developer documentation, however, lists Microsoft Azure (Foundry Models) and Oracle (OCI Enterprise AI) as "coming soon", with AWS available through Amazon SageMaker AI and Google Cloud through Model Garden.^[19]

API use

At the October 16 release, Reflection invited developers to sign up for a public beta of its first-party API at platform.reflection.ai, which it said is free to start.^[9] Its OpenAI-compatible base URL is https://api.reflection.ai/openai/v1, supporting Chat Completions and Models; a Reflection-native endpoint sits at https://api.reflection.ai/v1. This is Reflection's service, rather than an OpenAI-hosted model.^[4]

The released model's API identifier is Beam-1.0-501B-A23B, replacing the preview identifier Beam-501B-A23B. The documentation now lists a 1M-token context window (1,048,576 tokens, prompt and output combined), a 128K-token maximum output (131,072 tokens) and a knowledge cutoff of June 30, 2026.^[2]

Reasoning controls

Beam-1.0-501B-A23B always reasons. Its reasoning_effort values are low, medium, high, xhigh and max, and no value turns reasoning off. When a request omits the setting, the model's default effort applies; the documentation says this default can differ between organizations, and its example model object shows max.^[3][2] Unsupported values such as none and minimal return a 400 error.^[3]

The response separates message.reasoning_content from the final answer in message.content. Reasoning tokens count toward the completion budget. If that budget runs out during reasoning, finish_reason can be length and the answer can be null.^[3] In multi-turn conversations, every prior assistant message must be sent back with its non-empty reasoning_content, or the request fails with a 400 error.^[3]

Tool calls and structured output

With function calling, Beam requests application-defined functions; the application executes them and returns results. Its generated JSON arguments require validation before use. The conversation must retain the assistant's tool-call message, including reasoning, followed by one tool-result message for each call.^[6]

Structured output uses response_format: json_object requests a JSON object, while json_schema supplies a schema. Strict schema mode requires every object to set additionalProperties: false and require all its properties. Applications must check for refusals and truncated output before parsing the answer.^[7]

Mirror CLI and agent harnesses

Mirror CLI is Reflection's terminal coding agent. It reads and edits files, runs commands, and can run parallel tasks in separate repository worktrees; it uses Reflection's API and Beam-1.0-501B-A23B by default.^[22][5] Reflection says it trained Beam together with the Mirror harness, and that Mirror began as an internal tool with isolated workspaces, background sessions and Slack, Linear and GitHub integrations before being open-sourced.^[9] Its architecture pairs a Python frontend for prompts, skills and developer tooling with a Rust agent core that drives the model; Reflection says the minimal core doubles as an evaluation surface.^[9]

The source code is at github.com/reflection-oss/mirror under Apache 2.0, and the package installs with uv tool install reflection-mirror.^[22] The documentation describes Mirror as being in early beta and lists support for macOS 15 or later on Apple Silicon and Linux (glibc 2.28 or later) on x86-64 or ARM64; native Windows is not supported.^[5] The Beam safety report notes that Reflection's internal cyber evaluations ran through the publicly available version of Mirror.^[12]

Reflection also documents Beam configurations for Pi, OpenCode and Hermes Agent. These integrations use the model identifier, the OpenAI-compatible endpoint and a Reflection API key.^[5] Reflection's release post says early users tested Beam in stealth previews under codenames, including "MissingNo" through Nous Portal with Hermes and "Catjam" with OpenCode.^[9]

Customization

The model card says Reflection does not prohibit distillation, use of outputs to train other models, fine-tuning, parameter-efficient adaptation, quantization, merging, authorized defensive security research or good-faith adversarial evaluation.^[10] Reflection lists support in NVIDIA NeMo AutoModel, Megatron Bridge and Axolotl for supervised fine-tuning, and in Miles (RadixArk), NeMo RL (NVIDIA) and SkyRL for reinforcement learning; at release, the per-stack recipes were marked "coming soon".^[20] The release post also names Hugging Face TRL as a partner, describes a self-distillation loop that trains a LoRA adapter on verified traces (with recipes promised "in the coming days"), and says Reflection will adopt the OpenEnv environment standard for future runs.^[9]

Reinforcement learning with SkyRL

SkyRL, an Apache-2.0 reinforcement-learning library for language models from NovaSky (a group at UC Berkeley's Sky Computing Lab), announced day-zero support for Beam on October 16, 2026.^[26][29][30] It covers LoRA, BF16 full fine-tuning and MXFP8 RL, with vLLM generating rollouts and Megatron training the model.^[27][28] SkyRL says it worked from the official vLLM branch for Beam and the Megatron-Bridge implementation Reflection provided, and thanks Reflection for early access to the model.^[26] Beam support lives on SkyRL's beam-release branch, not its main branch, and runs from a Docker image that carries Beam builds of vLLM and Megatron-Bridge.^[27] Reflection's own customization page still marked its per-stack recipes "coming soon" when checked on October 19, 2026.^[20]

SkyRL validated training with the DAPO recipe (GRPO with clip-higher and DAPO's overlong-response penalty, without dynamic sampling) on DAPO-Math-17K, evaluating on AIME24 and AIME25. The runs used minimal reasoning effort (set through Beam's chat template; Reflection's hosted API does not accept minimal), 50 training steps (100 optimizer updates) and Rollout Routing Replay (R3), and SkyRL describes them as short validation runs that finished in 5 hours.^[26][27] It reported these results:^[26][27]

The average absolute difference between training-side and inference-side log-probabilities was about 0.02 without R3 and about 0.008 with it for BF16 rollouts, and about 0.03 with R3 for MXFP8 rollouts, where SkyRL also turned on geometric sequence masking as an off-policy correction.^[26][27] SkyRL also noted Beam's short reasoning: at minimal effort the model averaged about 1.4K tokens on AIME25.^[26]

SkyRL described several changes needed at 501B scale:^[26]

• Expert LoRA sizing in vLLM. With LoRA on every expert, rollouts were initially about 2.7x slower than the base model. vLLM padded each expert adapter slot to the full rank, although with normalize_moe_lora each expert adapter has rank r/top-k (8 for rank 64). Sizing the slots at their true rank raised decode throughput by 62% (276 to 447 tokens/s per GPU) and freed 10 GiB per GPU for the KV cache.
• Optimizer state on disk. With Megatron's CPU optimizer offload, full fine-tuning needed about 18 bytes of host memory per parameter (FP32 master weights and Adam moments, an FP32 gradient copy and offloaded BF16 weights), about 9 TB in total; with the other memory used by colocated training, this exhausted the roughly 13.5 TB of host RAM across 8 nodes. SkyRL instead streams each rank's optimizer state from node-local NVMe, cutting host RAM use to at most 3.2 TB.
• Model-specific details. SkyRL added logit soft-capping to its fused LM-head path, kept Beam's FP32 router weights in FP32 during weight sync between Megatron and vLLM, and enabled R3 in vLLM with pipeline parallelism greater than 1.

SkyRL says these changes let Beam be trained with LoRA on as few as 2 B200 nodes.^[26]

Safety evaluation

Reflection published the Beam Safety Technical Report with the weights. Under its Open Safety Framework (OSF), Reflection rates Beam "Limited" in all four systemic-risk categories it assesses (biological weapons, chemical weapons, loss of control and cyber offense). It defines Limited as no material shift in the offense-defense balance attributable to the model and no material expansion of the threat landscape relative to comparable open-weight models.^[12] These are Reflection's own determinations.

Main points from the report:^[12]

The model card repeats the Iris figures for each released precision: refusal or pivot rates of 88.9% (BF16), 89.7% (FP8) and 88.5% (NVFP4), and harmless-request compliance of 81.5%, 81.6% and 82.1%.^[10]

References

1. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13 ^14 ^15 ^16 ^17 ^18 ^19 ^20 ^21 ^22 ^23 ^24Reflection. "Introducing Beam: Reflection's 501B open-weight model". October 5, 2026 (results updated October 8, 2026).
2. ^1 ^2 ^3Reflection Developer Docs. "Models". Accessed October 7 and October 17, 2026.
3. ^1 ^2 ^3 ^4Reflection Developer Docs. "Reasoning". Accessed October 7 and October 17, 2026.
4. ^Reflection Developer Docs. "Introduction". Accessed October 7, 2026; see also "Reflection API overview", accessed October 17, 2026.
5. ^1 ^2 ^3Reflection Developer Docs. "Coding agent quickstart" and "Mirror CLI overview". Accessed October 17, 2026.
6. ^Reflection Developer Docs. "Tool calling". Accessed October 7, 2026.
7. ^Reflection Developer Docs. "Structured outputs". Accessed October 7, 2026.
8. ^DeepSeek-AI et al. "DeepSeek-V3 Technical Report," section 2.1.2. arXiv:2412.19437v2. February 18, 2025.
9. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13Reflection. "Beam is now available". October 16, 2026.
10. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13Reflection. "Beam-1.0-501B-A23B" model card. Hugging Face. Accessed October 17, 2026.
11. ^1 ^2 ^3 ^4 ^5 ^6 ^7Reflection. "Beam-1.0-501B-A23B-DFlash2" model card. Hugging Face. Accessed October 17, 2026.
12. ^1 ^2 ^3 ^4 ^5 ^6 ^7Reflection. "Beam Safety Technical Report". Accessed October 17, 2026.
13. ^1 ^2Reflection (@reflection_ai). Post announcing the open-weight release. X. October 16, 2026.
14. ^NVIDIA AI (@NVIDIAAI). Post on Beam's launch. X. October 16, 2026.
15. ^1 ^2 ^3 ^4Reflection Developer Docs. "Download the weights". Accessed October 17, 2026.
16. ^1 ^2 ^3 ^4 ^5Reflection Developer Docs. "NVFP4 quantization". Accessed October 17, 2026.
17. ^1 ^2 ^3 ^4Reflection Developer Docs. "FP8 quantization". Accessed October 17, 2026.
18. ^1 ^2Reflection Developer Docs. "Speculative decoding". Accessed October 17, 2026.
19. ^1 ^2Reflection Developer Docs. "Deployment overview" and "Third-party providers". Accessed October 17, 2026.
20. ^1 ^2 ^3Reflection Developer Docs. "Customize Beam". Accessed October 17 and October 19, 2026.
21. ^1 ^2Reflection Developer Docs. "Beam Harmony format". Accessed October 17, 2026.
22. ^1 ^2Reflection. "mirror". GitHub repository, Apache-2.0. Accessed October 17, 2026.
23. ^Artificial Analysis. "Beam 1.0: Intelligence, Performance & Price Analysis". Accessed October 17, 2026.
24. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10 ^11 ^12 ^13 ^14vLLM Blog (Inferact, Reflection and NVIDIA). "Serving Reflection Beam on vLLM from Day 0". October 16, 2026. Accessed October 19, 2026.
25. ^1 ^2 ^3 ^4 ^5 ^6vLLM Recipes. "reflection/Beam-1.0-501B-A23B". Updated October 16, 2026. Accessed October 19, 2026.
26. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10Sumanth Hegde and the SkyRL team. "Day 0 Support for Beam in SkyRL". SkyRL Blog. October 16, 2026.
27. ^1 ^2 ^3 ^4 ^5SkyRL Documentation. "Day 0 Support for Beam in SkyRL: LoRA, full fine-tuning and MXFP8". Accessed October 19, 2026.
28. ^1 ^2vLLM (@vllm_project). Post on Beam's day-0 support in vLLM and SkyRL. X. October 16, 2026.
29. ^NovaSky-AI. "SkyRL: A Modular Full-stack RL Library for LLMs". GitHub repository, Apache-2.0. Accessed October 19, 2026.
30. ^NovaSky. "NovaSky". Sky Computing Lab, UC Berkeley. Accessed October 19, 2026.