Contents

Beam offers an Apache 2.0 model with a one-million-token context window for coding and agent workflows, with support for self-hosting and fine-tuning. Its 23B active parameters reduce computation per token, but deployment requires enough memory to hold the 501B-parameter model.

Key Takeaways#

  • Reflection’s Beam supports text input and output, tool calls, and five reasoning settings from low to max.
  • Its Mixture-of-Experts (MoE) architecture keeps all 501B parameters in memory while activating about 23B per token.
  • The NVFP4 checkpoint is about 280 GB, and the release guide recommends four B200 GPUs for practical inference serving.
  • Start with hosted inference, then evaluate self-hosting and customization against your tasks and costs.

What You Can Control#

Released on October 16, 2026, Beam targets coding, long-context reasoning, and workflows that use tools. Its Apache 2.0 license lets teams host and modify the model under its terms. It is a strong option when control over infrastructure, model weights, and further training justifies the operational burden of a large model.

Beam supports Transformers, vLLM, and SGLang, and comes with a dedicated open-source Rust harness. Its tokenizer includes a response template that separates answers, reasoning, and tool calls into structured fields. Use the supplied parser when integrating the model. Manually splitting generated text introduces avoidable sources of bugs.

You can also retain reasoning across turns through preserve_thinking. Treat this as a setting to evaluate. Retaining longer conversation histories can affect context usage, latency, and cost.

Estimate Memory First#

Beam has 256 experts in each MoE layer and selects eight per token. Sparse activation reduces computation, but inactive experts still occupy memory. It will not necessarily match the speed of a dense 23B model. Performance depends on hardware, communication between GPUs, and serving configuration.

| Checkpoint | Weight Storage | Deployment Guideline | |---|---:|---| | BF16 | About 1 TB | Published vLLM example uses 16 H200 GPUs | | FP8 | Smaller than BF16 | Published SGLang example uses eight H200 GPUs | | NVFP4 | About 280 GB | Guide recommends four B200 GPUs |

Two B200 GPUs provide 360 GB of memory, enough to hold the NVFP4 weights but with limited headroom for runtime overhead, context, and concurrent requests. Four provide 720 GB. Native NVFP4 execution requires compatible Blackwell hardware. On Hopper hardware such as the H200, use a supported FP8 configuration.

Try a Hosted API#

The release information lists Beam as available through Baseten, Fireworks, and Together on Hugging Face Inference Providers. If the need for self-hosting is still unclear, a hosted service is the easiest starting point. Before testing, check each provider’s current availability, pricing, context limits, and supported features.

Build a small evaluation based on real work, such as repository fixes, information extraction from documents, or sequences of tool operations with explicit success criteria. Compare the default reasoning setting, medium, with high, and record task completion, output validity, latency, and token usage.

For self-hosting, start with a published vLLM or SGLang recipe that matches your checkpoint and GPUs. Both support speculative decoding with DFlash2, in which Beam verifies tokens proposed by a smaller model. Measure the effect on your actual workload rather than assuming throughput will improve.

Use Long Context as Needed#

Beam supports 1,048,576 tokens through hybrid attention. Of its 52 layers, 43 maintain a 512-token sliding window, while nine attend to the entire sequence.

This substantially reduces KV cache growth. The release information estimates that the BF16 KV cache for one maximum-length sequence requires about 36 GiB, compared with 208 GiB if all layers used global attention. These figures use the Transformers dynamic cache and exclude weights and other runtime memory.

A large context window does not guarantee reliable information retrieval from every input. Test whether Beam can find the right evidence, follow instructions, and produce valid output at the lengths you actually need. Increase context only when the improvement in task completion justifies the added cost.

Measure Failures Before Customizing#

Reflection reports BF16 scores of 81.6% on SWE-bench Verified and 80.1% on Terminal Bench v2.1. These are vendor-reported results, not independent verification. The five informal task evaluations at release are also too few to establish broad reliability.

The published TRL recipe for further training uses LoRA adapters rather than updating all parameters. The reference configuration fits on a single node with eight B300 GPUs. In an experiment testing compliance with a requested language, successes on 16 prompts excluded from training rose from three before training to 16 afterward, but reasoning correctness was not measured.

Reinforcement learning across all parameters requires far more hardware. One Miles reference configuration uses 96 H200 GPUs. Before starting training, identify recurring failures that cannot be resolved through prompts, tool schemas, or parser integration. Fine-tuning needs a measurable goal.

Next Steps#

Run 20 representative tasks on hosted Beam with the medium and high reasoning settings, and record success rate, latency, and cost before choosing a deployment configuration.

Source: https://huggingface.co/blog/reflection-beam

Contents