Beam’s headline number is the least interesting thing about it.
Reflection AI announced Beam on October 5, 2026 — its first open-weight model, a sparse Mixture-of-Experts build with 501 billion total parameters and 23 billion active. The internet latched onto the 501B. I build bots for a living, and the number I care about is 23. That’s the one that decides whether a model lives in your agent loop or stays a demo you admire from a distance.
Why active parameters are the number that pays your bill
In a sparse MoE, total parameters tell you how much knowledge is sitting in storage. Active parameters tell you how much of it fires per token. Beam keeps 501B in the vault and routes roughly 23B of it per forward pass. For anyone who has watched an agent run burn through tokens on a multi-step task, that ratio is the whole story.
Reflection says Beam competes with larger open models like GLM 5.2 while using 3 to 4x less inference compute on reasoning benchmarks. Read that again with a builder’s hat on. Reasoning benchmarks are the expensive kind — long chains, lots of generated tokens, retries. If you cut compute per reasoning task by three or four times, you don’t just save money. You change what you’re willing to build.
A few things that get unblocked at that cost profile:
- Agents that re-plan instead of committing to a first draft, because a second pass isn’t a budget decision
- Self-critique loops where the model reviews its own output before you ship it downstream
- Parallel candidate generation, then pick the best, rather than praying one shot lands
- Longer tool-use chains where every step costs a model call
Every one of those patterns is something I’ve cut from a project because the per-step cost made the math ugly. Cheaper reasoning doesn’t make bots smarter by itself. It makes the architectures that make bots smarter actually affordable.
The coding number
Beam reports 80.9% on SWE-bench Verified, which is the benchmark closest to what a coding agent actually does — take a real repository issue, make changes, pass tests. Reflection is pitching Beam for coding, reasoning, and agentic workloads, and that trio is not a coincidence. Those three are the same job described three ways. An agent that fixes a bug has to reason about the codebase, write the patch, and drive the tools that verify it.
Benchmarks are benchmarks. I’ll trust my own eval suite over any published score, and so should you. But a number in that range on SWE-bench Verified means Beam is credible for the thing I’d actually point it at.
The license is the quiet headline
Reflection plans to release the weights under Apache 2.0 and MIT. For a lot of the people reading this, that matters more than any score. Permissive licensing means you can host it, fine-tune it, wrap it in a product, and ship it to customers without a lawyer in the loop. It means the model can live on your infrastructure, which means your users’ data can too.
Among the models it’s being compared against, Beam is the smallest by total parameters, and its 23B active count sits below GLM-5.2 and Nemotron 3 Ultra. Smallest in a comparison set is usually a weakness. Here it reads as the design goal.
What you can’t do yet
Nothing, basically. The weights aren’t out. Reflection says it’s finishing final red-teaming and will publish the weights, technical report, model card, and developer tools through the rest of October 2026. Until then, access runs through an early access waitlist.
So treat this as a planning signal, not a tool. Here’s what I’d do with the gap:
- Get on the waitlist. Early access is where you find out how the thing actually behaves on your workload.
- Build your eval set now. Pull ten to twenty real tasks from your own backlog, the kind your current bot gets wrong. That’s a better test than any public leaderboard.
- Price out your serving path. A 501B MoE needs memory for all 501B even if only 23B computes. Figure out whether that’s your hardware, a rented cluster, or a hosted endpoint before you promise anyone a launch date.
- Read the model card when it lands. Context window, tool-calling format, and recommended sampling settings will shape your integration more than the parameter count will.
My read
Beam looks like a model built by people who have operated agents in production rather than just trained them. The sparse design, the compute efficiency claim, the agentic framing, the permissive license — those choices point the same direction, toward running the thing at scale on your own terms.
I’m holding judgment until the weights land and I can run my own tasks through it. But if the efficiency claim survives contact with real workloads, Beam becomes the open model I reach for when a bot needs to think more than once.
🕒 Published: