October 5, 2026. Reflection AI announced Beam, and the first thing to know is that you couldn’t download it.
Reflection’s announcement calls Beam the company’s first open-weight model. It’s a sparse Mixture-of-Experts with 501 billion total parameters and 23 billion active, built for coding, reasoning, and agentic workloads. CellCog’s writeup adds the context. Reflection is a Brooklyn lab founded in 2024 by two former Google DeepMind researchers. At announcement, Beam was in final red-teaming and evaluations, with early access by sign-up. The company’s promise: “We will release the weights, technical report, model card, and developer artifacts later this month.”
That’s a press release with a deadline attached. Press releases with deadlines are easy to write.
Eleven days later the deadline held. This post covers what shipped, what the benchmark data does and doesn’t say, and what it takes to run a model this size yourself.
What shipped on October 16 #
Data Studios reports that Reflection published the Beam 1.0 weights on October 16, 2026, under the Apache 2.0 license. A model card and safety documentation came with them, plus deployment integrations. The same writeup gives the architecture as 501.3 billion total parameters with roughly 23.4 billion activated per token, and a context window of one million tokens.
Explainx frames the release as a US answer to DeepSeek and Qwen. That’s their framing, not mine. I’d rather judge the model than the geopolitics.
On the license, Apache 2.0 is the permissive end of the spectrum. You can run it, fine-tune it, and ship it in a product without a negotiation. We made the same call on the Qwen release. In our Qwen3.8-Max piece, the license line was the real news and the scoreboard was secondary. The same applies here. A 501B model you can legally build on is a different object from a 501B model you can only rent.
One more thing from the timeline, flagged as unconfirmed. Explainx’s update log notes that on October 10 a press report said Nvidia was in talks to acquire Reflection or invest more. That log says what’s confirmed and what isn’t. I’m not building on it. But if you’re deciding whether to depend on a lab’s future releases, ownership uncertainty is worth a line in your risk notes.
The pretraining claim #
Reflection says Beam was pretrained on 23.8 trillion diverse, curated, high-quality tokens. The data came from the web and proprietary licensed datasets. The lab says that matches or outperforms available similar-sized open base models. It also says it invested heavily in reinforcement learning, building the algorithms, training environments, and infrastructure for it.
Treat both as vendor claims until the technical report gets a real read. “Matches or outperforms” is a comparison against a set the vendor picked. I’m not saying it’s wrong. I’m saying we haven’t checked it, and nothing in our sources lets us.
The reinforcement learning piece is the more interesting half for builders. Explainx notes that Hugging Face now hosts reinforcement learning environments on the Hub, the same kind of training task pool Beam used. If agentic quality comes from environments rather than raw parameter count, the moat moves. It moves from “who has the biggest cluster” to “who has the best task pool.” That’s a bet worth watching.
What the benchmark aggregate says #
Here’s the number everyone will quote. BenchLM’s model page, with data as of October 20, 2026, gives this scorecard, next to what nobody has published yet:
| area | Beam | what it tells you |
|---|---|---|
| Capability | 51.6/100 | median 49.9; rank #95 of 228 |
| Speed | 349 tok/s | median 93.5; setup not stated |
| Price | not published | median $0.72 per million input tokens |
| Verified score | blank | no independent check |
| Coding, reasoning, agentic | not published | Reflection’s target workloads |
| Pretraining | vendor claim | “matches or outperforms” peers, unchecked |
Read that capability line twice. 51.6 against a median of 49.9 is a 1.7-point margin, barely above middle. Rank 95 of 228 puts Beam ahead of about 58% of the field, in the middle of the pack and not at the front. If you came for “frontier-class open weights,” this aggregate doesn’t say that. It says “solidly competent, slightly above median.”
The speed number is the standout, at roughly 3.7 times the field median. But I can’t tell from the page what serving stack or hardware produced it. And the price field tells you why: nobody is selling Beam from a first-party API, so there’s no apples-to-apples rate. A decode figure with no stated setup is a number, not a measurement you can reproduce.
The empty Verified field matters too. It means the snapshot has no independently verified score behind the capability figure.
The blank rows are deliberate. The sources I have give an aggregate, not per-benchmark results for coding, reasoning, or agentic work. I’m not going to quote SWE-style or terminal-task scores for Beam, because any figure I gave you would be invented. If you need those, the model card and technical report are the place to go, not a secondary summary.
Why I don’t trust a single score #
An aggregate compresses a lot of behavior into one number, and Beam’s 51.6 is exactly that kind of number. We’ve been burned by this compression in our own pipeline, so this isn’t abstract.
We run local models for topic ranking and citation checking. In one comparison, we tested three candidates on a ranking task and a citation-reconcile task:
| model | size | separation | correct ordering | latency |
|---|---|---|---|---|
llama3.2:3b |
2.0 GB | −13.9 | 0/3 | 1.2s |
phi4:14b |
9.1 GB | +22.1 | 2/3 | 1.6s |
qwen2.5:32b |
19.9 GB | +23.3 | 3/3 | 11.7s |
Look at the small one. llama3.2:3b scored 5/5 on output format in 1.2 seconds. Then it ranked an off-brief LinkedIn profile at 80, its highest score, above both candidates that actually fit. Inverted judgment, perfect paperwork.
If we’d picked it off speed and format alone, it would have looked like a clean 10× win on every metric we’d checked. It would also have quietly wrecked topic selection. Silent degradation that passes every check nobody thought to run.
The citation task split the field differently. Only gemma-4-31B caught the fabricated source, 4 out of 4. Both qwen2.5:32b and phi4:14b scored 0 out of 4. Mechanical accuracy like parsing and URL validity was fine at 14B. The semantic catch needed the bigger model.
So when you see “51.6/100,” ask what’s inside it. A model can sit mid-pack on an aggregate and still be the right pick for your one job. It can also top an aggregate and fail yours. The only number that settles it is the one you measure on your own task.
Fast on paper, slower in your app #
The 349 tokens per second deserves a second look, because decode speed is the metric that travels furthest from reality.
Raw decode throughput is what the model produces once it’s generating. What your application receives is something else. It includes queueing, prompt processing, retries, and whatever sits between the model and your code. We log both in our own cost records, and the two diverge per model.
That chart is ours, from our own runs, and it isn’t about Beam. It’s there to make a point. A published tokens-per-second figure is an upper bound on what you’ll feel. Before you plan a workload around 349 tok/s, measure delivered throughput on your own stack, with your own prompts, at your own concurrency. The gap is real and it varies by model.
Can you run it? #
This is where a 501B model stops being a headline and becomes a purchase order.
Some arithmetic, with no vendor numbers involved. Parameters times bytes per parameter gives weight memory. At 8-bit precision, 501 billion parameters is on the order of 501 GB of weights. At 4-bit, roughly half that, around 250 GB. That’s before the KV cache, which at a million-token context can be its own serious memory bill. Treat those as floors, not specs.
The “23B active” figure helps with compute, not capacity. Per token, a MoE only runs its routed experts, so the arithmetic per token looks like a roughly 23B model. But every expert’s weights still need to live somewhere you can reach quickly. Sparse activation buys you speed. It doesn’t buy you a smaller footprint.
For most of the readers this site is written for, that settles it. A single 32GB consumer card isn’t the target for this model. You’re looking at a multi-GPU server, a large unified-memory machine with heavy quantization, or off experts to system RAM and accepting the speed hit. Reflection’s own materials point at deployment integrations, which suggests hosted and cluster serving is the intended path. I wouldn’t plan a home setup around Beam without testing the quantized builds first. This is the same logic from our H1 2026 open-weight roundup. The open-weight story stopped being one story. There’s the frontier-scale tier that you rent or host on a cluster. Then there’s the tier that fits on hardware you own. Beam sits firmly in the first.
Where Beam fits #
Three questions decide whether Beam matters to you.
Do you need the license more than the score? If you need to self-host a large model and can’t accept restrictive terms, Apache 2.0 at this scale is rare. The weights being out matters more than where it ranks.
Is your workload agentic and coding-heavy? That’s what Reflection built it for. It’s also where a mid-pack aggregate could hide a strong or weak spot. Test on your tasks. Don’t trust the aggregate in either direction.
Do you have the hardware or the hosting budget? If not, the question is moot, and a smaller model that fits will beat a bigger one you can’t run.
For everyone else, the lesson is about the American open-weight shelf. We wrote earlier about OpenAI’s long silence after gpt-oss and argued you should build as if no successor is coming. Beam doesn’t contradict that. It does add a new, credible name to the list of labs shipping permissive weights. That’s a better position than relying on one vendor’s promises.
What I’d do this week #
If you’re evaluating Beam, here’s the order I’d run it.
- Read the model card and technical report before the leaderboards. Per-benchmark numbers for coding, reasoning, and agentic tasks, plus the training details, live there, not in aggregators.
- Pick your own eval. Ten to twenty real tasks from your workload beats any public score. Include one task where the answer is a judgment call, not a format. That’s the one our small model failed.
- Measure delivered throughput, not decode. Run it through your actual stack at your actual concurrency.
- Do the memory math with KV cache included. A million-token window is a capability and a bill.
- Compare against something smaller. If a 14B or 32B model gets you the same result on your task, the 501B isn’t earning its footprint. In our ranking test, the 32B beat the 14B by 1.2 points of separation at seven times the latency. At a sample that thin, that margin is noise.
The bottom line #
Beam is a real release. The weights shipped on the date Reflection promised, under Apache 2.0, with a model card. That’s more than a lot of announcements deliver.
It isn’t a leaderboard-topping release. The aggregate scores it 51.6 against a median of 49.9 and ranks it #95 of 228, with a blank verified field and a speed number of 349 tok/s that comes with no stated setup. The pretraining and reinforcement learning claims come from Reflection and wait on independent checking.
So here’s my position. Beam is worth testing if you have the hardware or the hosting budget and want a permissively licensed large model for agentic and coding work. It isn’t worth rearranging your stack on the strength of a launch post and a median-adjacent score. Run it on your tasks and measure what your application actually receives. Then decide. The 3B model that aced the paperwork and failed the judgment taught us that a score is only a claim until your own workload confirms it.