Reflection Beam: 501B Open Weights Under Apache 2.0
Reflection Beam: 501B Open Weights Under Apache 2.0
Reflection AI's 501B-parameter model for coding and agents just dropped its weights under Apache 2.0 — no custom license, no gatekeeping. Here's what it can actually do, what it'll cost to run, and whether you should care.
The open-weight race just got its most interesting release of the month — and this time, the weights actually shipped. Reflection AI, a new US lab backed by Nvidia, announced Beam on October 5: a 501-billion-parameter mixture-of-experts model aimed squarely at coding tools and AI agents. The announcement was the teaser. The real event happened this week, when the full weights landed on Hugging Face under the Apache 2.0 license, with day-one support in Transformers, vLLM, and SGLang.
That last part is what separates a press release from a developer event. Plenty of "open" models arrive with custom licenses, waitlists, and API-only access. Beam arrived as downloadable weights you can own, fine-tune, and serve behind your own infrastructure. If you build agents or coding tools, this one deserves your attention — with the usual caveats, which I'll get to.
What Beam actually is (and what 501B really means)
Let's decode the headline number, because it's the least useful number in the announcement. Beam is a sparse mixture-of-experts model: 501 billion parameters total, but only about 23 billion "awake" for any given token. The architecture runs 52 layers — three dense, then 49 MoE layers with 256 experts each, of which the router picks 8 per token.
What does that mean in practice? Your per-token compute bill follows the 23B, not the 501B. But your GPU memory bill follows the full 501B, because all the experts have to sit in memory whether they're awake or not. One builder put it well: your inference bill follows the active parameters; your warehouse bill follows the total.
A few engineering details worth knowing, all from the official Hugging Face announcement:
- Context: 1M tokens, made practical by hybrid attention — 43 sliding-window layers that only look back 512 tokens, plus 9 global layers that see everything. The KV cache grows at 36 KiB per token instead of 208, so a full 1M-token context costs about 36 GB of cache, not 208.
- Training: Reflection says 23.8 trillion pretraining tokens, then reinforcement learning on 10,500 GB300 GPUs over four weeks with more than 100 million rollouts — focused on agentic coding, not generic chat.
- Reasoning control: five reasoning settings (low, medium, high, xhigh, max) plus tool calling through a dedicated grammar, so agents get structured tool calls instead of regex-parsed text.
- Serving: native Transformers implementation, vLLM and SGLang recipes, a Rust-based harness, and a speculative-decoding drafter for faster generation at scale.
The license is the actual story
Here's why Beam matters more than its benchmark table: Apache 2.0. That license means you can use it commercially, modify it, fine-tune it, and self-host it — no per-seat fees, no "research only" clauses, no custom commercial terms to run past your legal team. It's the license your company's lawyers already know.
This lands in a month where "open" increasingly comes with asterisks. Meta's Muse Spark, for example, shipped under a limited commercial license — genuinely open weights, but with strings attached. Beam has no such strings. For enterprises with regulated data, strict data-residency requirements, or IP they can't send to a third-party API, that's the difference between "interesting" and "deployable."
One honest caveat: read the released license text before you ship anything. License terms can differ between the weights and the accompanying code, and the model card is the document that counts — not the launch post.
The benchmarks: legitimately strong on code, with asterisks
Reflection published an unusually detailed benchmark table with the release — scores across three checkpoint formats (BF16, FP8, NVFP4), which is itself a good sign. The headline numbers for the BF16 checkpoint:
- SWE-bench Verified: 81.6% — automated bug-fixing on real repos
- Terminal Bench v2.1: 80.1% — agentic terminal tasks
- AIME 2026: 97.7% — competition math
- GPQA Diamond: 90.6% — graduate-level science questions
- MCP Atlas: 80.8% — tool-calling/agent protocol tasks
- BrowseComp: 76.8% — web browsing with context management
Now the asterisks. These are vendor-reported numbers — TechCrunch noted at the announcement that outside labs hadn't independently verified them. Independent write-ups comparing the figures put Beam roughly at GLM-5.2's level on reasoning and agentic coding, ahead of Nvidia's Nemotron 3 Ultra on SWE-bench (80.9 vs 70.7 in one comparison), but behind DeepSeek V4.1 Flash on Terminal Bench (90.6 vs 80.1) and behind GLM-5.3 and Kimi K3 on DeepSWE.
Reflection's actual pitch isn't "best scores" — it's a cost ratio. The company claims Beam matches GLM-5.2-level reasoning at roughly 3–4x less inference compute. That claim rests on their own estimates, not measured dollar costs. Which brings us to the callout:
Beam's 3–4x efficiency claim is testable — and now that the weights are downloadable, there's no excuse not to test it. Before planning anything on Beam, run SWE-bench Verified and Terminal Bench against whatever open model you serve today, then swap Beam in and measure on your own workload. Benchmarks predict leaderboard position; only your data predicts production behavior.
The hardware bill (the part nobody puts in the headline)
This is the section that decides whether Beam is a tool or a spectator sport for you. The BF16 checkpoint is roughly 1 terabyte. The NVFP4 checkpoint — the practical one — shrinks that to about 280 GB, but it needs Blackwell GPUs. FP8 checkpoints cover Hopper and Ampere hardware.
Reflection's own guidance: a single B200 has 180 GB of HBM, so two of them (360 GB) can technically hold the NVFP4 weights — with almost nothing left for activations and the KV cache. Plan for four B200s (720 GB), which leaves room for long contexts and concurrent requests. Alternatives: a full 8xB200 node, two B300s, or 8x RTX Pro 6000s. On AWS SageMaker JumpStart, the FP8 weights need an ml.p5.48xlarge (H100) or ml.p5e/p5en.48xlarge (H200) instance; NVFP4 needs ml.p6-b200.48xlarge.
The honest summary, and it's becoming the familiar shape of the open-model market: a model can be openly licensed and technically downloadable while remaining expensive to serve at full capability. "Open" and "easy to run" are two very different promises. Unless your contracts require data to stay on your own infrastructure, a hosted open-weight endpoint will usually be cheaper than the GPU bill — and that's fine. The license still gives you the exit option, which is the whole point.
How to try Beam this week
You don't need four B200s to touch the model. A few doors are open right now:
- Free API beta: Reflection announced a free API beta alongside the weights release on its official X account — the fastest way to benchmark it against your current stack.
- Free in OpenCode: Beam is available free in OpenCode for a limited time with 1M context — a genuinely useful way to try a 501B model inside your actual dev workflow.
- Self-serve code: pip install the latest transformers (5.20.1+), then load reflection/Beam-1.0-501B-A23B — day-zero support means no waiting for library updates.
- Build bounty: Reflection and Hugging Face are offering $10,000 in Hub credits for the best community projects built on Beam — quants, benchmarks, RL environments, demos.
My suggestion for builders: start with the eval harness, not the model. Get SWE-bench Verified and Terminal Bench running locally against whatever you serve today. When you're ready, Beam drops in as a candidate — and that 3–4x efficiency claim becomes something you measured, not something you read.
Frequently asked questions
Can I use Reflection Beam commercially?
Yes — that's the point of the Apache 2.0 license. It permits commercial use, modification, fine-tuning, and self-hosting without custom restrictions. Still, read the released license text in the model card before shipping: terms can differ between the weights and the accompanying code.
Can I run Beam on my own GPU?
Realistically, no — not on a workstation. Even the most compressed practical checkpoint (NVFP4, ~280 GB) needs data-center GPUs like B200s, and the BF16 checkpoint is around 1 TB. For hands-on access, use the free API beta, Inference Providers, or the free OpenCode window instead.
How does Beam compare to DeepSeek, GLM, and Qwen open models?
On company-reported numbers, Beam sits roughly at GLM-5.2's level on reasoning and agentic coding, ahead of Nemotron 3 Ultra on SWE-bench but behind DeepSeek V4.1 Flash on Terminal Bench. Reflection's differentiator is efficiency — its claim of 3–4x less inference compute than GLM-5.2 — which is vendor-reported and worth verifying yourself now that the weights are out.
What does "23B active, 501B total" actually mean?
Beam is a mixture-of-experts model with 256 experts per MoE layer, and the router wakes only 8 of them per token. So each token is computed by about 23B parameters (that's your speed and per-token cost), while all 501B parameters must stay loaded in GPU memory (that's your hardware bill).
Why does Apache 2.0 matter more than other "open" licenses?
Because it's the standard permissive license your legal team already understands — no custom commercial restrictions, no usage caps, no field-of-use limits. Compare that with custom licenses like the limited commercial license on Meta's Muse Spark weights: genuinely open, but with strings. Apache 2.0 has no strings.
The bottom line
Beam is the rare open-weight release where the license is more exciting than the leaderboard. Apache 2.0 on a 501B model with real agentic-coding chops, downloadable weights, day-zero serving support, and honest engineering (an efficiency-first MoE, a genuinely clever 1M-context attention design) — that's a combination the open ecosystem hasn't had at this scale.
It arrives with two asterisks: vendor-reported benchmarks and a data-center hardware bill. If you're a team with regulated data, strict data residency, or serious agent workloads at scale, Beam is worth evaluating this week — the free API beta and the OpenCode window make that cheap. If you're an individual dev with one GPU, this one's a spectator sport for now. The quantized community builds will decide how far downmarket Beam goes. Watch what the community does with it in the next two weeks — that's when we'll learn what Beam is actually worth.
Sources and further reading
- Hugging Face — "Welcome Beam: a 501B open model you can own, customize, and scale" (official announcement with benchmarks, architecture, and serving recipes)
- AIstify — "Reflection Releases Beam, a 501B Open Model for Coding and AI Agents" (Oct 17, 2026)
- Layer3 Labs — "Beam Benchmarks: Eval Numbers & Real-World Limits"
- Dev.to — "501B Stored, 23B Awake: What Reflection's Beam Means for Builders Who Self-Host"
- @reflection_ai on X — official Beam announcement (open weights under Apache 2.0, free API beta)
- @opencode on X — Beam free in OpenCode for a limited time
