Beam 1.0 vs Gemma 4 12B: 501 Billion Parameters Against 12, and What the Gap Actually Buys

One of these models fits on a laptop. The other needs a rack, and the gap between them is a factor of forty. Reflection Beam 1.0 is a sparse mixture-of-experts model with 501.3 billion total parameters that wakes 23.4 billion of them per token — announced by Reflection on 5 October 2026 as a waitlisted preview, and actually shipped as downloadable weights on 16 October 2026 under Apache 2.0 in BF16, FP8 and NVFP4 builds, with a small DFlash2 speculative-decoding drafter alongside them. G​emma 4 12B is G​oogle DeepMind's encoder-free 11.95-billion-parameter dense model, released 3 June 2026, which reads text, images, audio and video frames, writes text, and quantises down to something a 16GB machine can hold. Both licences are permissive, both outputs are text, and both are on Hugging Face right now. Almost nothing else about them is the same, and the useful question is not which is smarter — it is which of the two answers your problem without a purchase order.

This matters more than it usually would, because for eleven days Beam 1.0 was a model you could read about and not have. Reflection's October 5 announcement promised Apache 2.0 weights "later this month," and the repository sat empty. As of 16 October 2026 the collection is live with four repositories and the model card carries a full evaluation table. That release is the reason this comparison can be written as a comparison at all, rather than as a note about a headline.

Where the two of them stand, in one pass

Everything below is either the vendor's own documentation or Artificial Analysis. Where a number is the vendor's and nobody has reproduced it, this page says so where it sits rather than in a disclaimer at the bottom.

• Total parameters — Beam 1.0 501.3B vs G​emma 4 12B 11.95B. The ratio is roughly 42 to 1.

• Active parameters per token — 23.4B vs 11.95B. The ratio collapses to about 2 to 1, which is the whole trick: a sparse model only pays for the part of itself it uses.

• Architecture — Beam 1.0 is a 52-layer MoE with 256 experts, three dense layers and 49 expert layers, interleaved local and global attention, and gated grouped-query attention with sliding-window attention; G​emma 4 12B is dense, 48 layers, with no multimodal encoders at all — the vision and audio handling is trained into the model rather than bolted on.

• Context window — Beam 1.0 1,000,000 tokens on the model card; G​emma 4 12B 262,144 tokens. Both are the largest figure their respective families offer.

• Modality — Beam 1.0 is text in, text out, and its card says so plainly; G​emma 4 12B takes text, image, audio and video frames in and returns text.

• Licence — Apache 2.0 on both, commercially usable, no user caps. This is the closest the two models come to being the same thing.

• Published evaluation — Beam 1.0 ships an evaluation table across BF16, FP8 and NVFP4 checkpoints; G​emma 4 12B's card carries G​oogle's own figures and has been independently scored since June.

• Independent score — Artificial Analysis Intelligence Index v4.3.2 puts Beam 1.0 at 30, ranked 19th of 120 models in its comparison class, and G​emma 4 12B at 14, ranked 20th of 141 — a 16-point gap in the larger model's favour, with G​emma's figure carrying an "estimated" footnote because independent evaluation on the 12B was still pending.

What Beam 1.0 actually is, now that the weights exist

The model card reads: 501.3 billion total parameters, 23.4 billion active, 52 layers of which three are dense and 49 are MoE, 256 experts, a 152,000-token vocabulary, a knowledge cutoff of 30 June 2026, and text-only modality. The chat template is a modified Harmony format with two channels — analysis and final — and a reasoning_effort setting that accepts either an integer or one of minimal, low, medium, high, xhigh and max, mapping to 8, 32, 64, 128, 256 and 512. Served default when the parameter is unset is 512. The template's own documentation notes that minimal, at 8, is the smallest effort the training data ever sampled, so a smaller budget is not respected.

Three things about that specification are worth pulling out, because they are the parts that decide whether you can use it.

The first is that the effort setting has no off switch. Beam always reasons; you choose how much. For an agent loop that means every turn carries a deliberation prefix that gets billed and, if you replay history, re-billed. The template even raises an error when allow_missing_thinking is set to false and a prior assistant turn has dropped its reasoning, precisely because stripping it degrades output. That is a documented cost, not a bug.

The second is the quantised builds. Reflection published FP8 and NVFP4 checkpoints on the same day as the BF16 model, alongside the DFlash2 drafter. The NVFP4 repository is listed at 255B against the BF16 501B, and the card attributes the quantisation to llm-compressor with credit to N​VIDIA staff for guidance. Having a four-bit build on day zero changes who can run this at all — 501B at bfloat16 is roughly a terabyte of weights, which is a different purchasing conversation from 255B at four bits.

The third is what is missing. There is no serving recommendation on the card, no published hardware floor, and no published API price anywhere on Reflection's own properties. Artificial Analysis's page for the model records the price fields as unavailable and notes "No publicly available API" — which, for a model whose whole pitch is that it is cheap to run, is the row you would have wanted filled in.

What G​emma 4 12B is, and why the size is the argument

G​oogle's card gives G​emma 4 12B 11.95 billion parameters across 48 layers, a 262,144-token context, a 262,000-token shared vocabulary across the whole family, and a 1,024-token sliding window — double what the smaller E2B and E4B sizes use. Attention interleaves local sliding-window attention with full global attention, and the final layer is always global. It is pre-trained on more than 140 languages with out-of-the-box support claimed for 35 or more.

The interesting engineering decision is architectural: the model has no separate encoders. G​oogle's framing is that multimodal handling was trained in rather than attached, which is why the same checkpoint serves vision and audio without a second set of weights to load. On a device, that is the difference between a deployable model and a pipeline.

G​oogle also shipped quantisation-aware training rather than relying on a post-hoc quantiser, and publishes a QAT GGUF at roughly 6.98 GB for the weights plus a small multimodal projector. Community quantisations go further down: the widely mirrored Unsloth build runs from about 4.2 GB at the most aggressive 2-bit through 7.12 GB at Q4_K_M and 12.67 GB at Q8_0. Apple-silicon MLX builds land near 12.7 GB at 8-bit. The full-precision instruction-tuned checkpoint, by contrast, is a single 23.92 GB safetensors file — the raw bfloat16 footprint before any KV cache, which is the number that tells you a 16GB machine cannot hold it unquantised and a 24GB card can.

Independent scoring has been available since shortly after release, which is the asymmetry that runs through this whole page. Artificial Analysis measures the 12B at 14 on Intelligence Index v4.3.2, 117.6 output tokens per second, 2.43 seconds to first token, and $0.10 per million input tokens against $0.30 per million output. G​oogle's own card reports 78.2 on MMLU Pro, 77.8 on GPQA Diamond, 77.5 on AIME 2026 without tools, 72.0 on LiveCodeBench v6 with a Codeforces ELO of 1659, 69.1 on MMMU Pro and 43.4 on MRCR v2 at 128K with eight needles.

The comparison that does not exist

Beam 1.0's card reports SWE-bench Verified at 81.6% on the BF16 checkpoint, 80.2% on FP8 and 80.7% on NVFP4; Terminal Bench v2.1 at 80.1, 78.9 and 78.4; SWE Bench Pro v1 at 66.1, 65.9 and 65.6; DeepSWE v1.1 at 43.3, 43.0 and 42.7; GPQA Diamond at 90.6, 90.3 and 89.3; AIME 2026 at 97.7, 98.0 and 97.5; LiveCodeBench at 88.3, 88.1 and 87.4; MCP Atlas at 80.8, 81.5 and 80.5 and IFBench at 79.6, 80.7 and 79.2. Evaluations used temperature 0.7 and top-p 0.99. All of that is Reflection's own reporting and none of it has been reproduced by a third party.

G​emma 4 12B's card reports its own figures, also unreproduced at the per-benchmark level, and Artificial Analysis has scored the model independently. Now put the two side by side and try to subtract. You cannot. Beam's table is a frontier-model table of agentic coding and tool-use benchmarks. G​emma's is a table of multimodal understanding and reasoning benchmarks. Where the two overlap — GPQA Diamond and AIME, essentially — the harnesses, the reasoning-effort settings and the sampling parameters are undocumented on one side and unknown on the other. A 90.6 against a 77.8 on GPQA reads like a 13-point gap, and it is a comparison of one lab's setup against another lab's.

The only number on this page where a single organisation measured both models is the Intelligence Index, and there the gap is 30 against 14. That is a real measurement by a third party under a documented composite. It is also a 16-point gap for a model with 42 times the parameter count and, on the evidence available, a different deployment class entirely. Nobody should be surprised by it.

What each one costs to actually run

Neither Beam 1.0 nor G​emma 4 12B is on our catalogue. What OrcaRouter routes from the G​emma 4 family is the two sizes we carry: Gemma 4 26B A4B at $0.06 per million input tokens and $0.33 per million output with a 262,144-token context, and G​emma 4 31B at $0.13 and $0.38 — provider list price passed through with no markup, read off our own model list on 16 October 2026. Beam 1.0 is not something we serve, and this page does not pretend otherwise; the way to use it today is to download it from Reflection's Hugging Face collection or call Reflection's own API.

That leaves the honest cost comparison as a hardware comparison, which is the version of it that actually matters here. If you already own the machine, G​emma 4 12B at four bits is a download and an afternoon. If you do not, the 12B's metered equivalent is roughly the cheapest thing on our list — thirty cents per million output tokens — while a 501B model at 23B active is a GPU rental that has not been priced for you anywhere, because Reflection has not published a rate.

Which of the two is your model

Pick G​emma 4 12B if the work is multimodal, if it has to run on hardware you already own or a device you ship to, if latency in the low hundreds of milliseconds to first token is acceptable, and if a 256K context covers your documents. The encoder-free design and the quantisation-aware training are both aimed squarely at that reader, and the Apache 2.0 licence means you can ship a derivative without a conversation with G​oogle. The cost of the choice is capability: 14 on the independent index is a long way below the frontier, and the benchmark set that matters most to you — agentic coding, repository-scale reasoning — is not the set G​oogle published.

Pick Beam 1.0 if the work is coding, tool use and long-horizon agentic execution, if you have cluster access or a serving partner, and if you can absorb an unpriced API and an always-on reasoning budget. The published benchmarks are aimed at exactly that workload, the four-bit build makes the hardware conversation materially easier than the parameter count suggests, and the licence carries no restriction that would stop a commercial fine-tune.

Pick neither if what you actually need is an answer this week. Both of these are models you have to run. The comparisons that matter for that decision — a served model at a published rate, on a key you already hold — are a different page, and this one is about the two ends of the open-weights spectrum rather than the middle where most production traffic lives.

What would change this page

Two things. An independent benchmark that puts Beam 1.0 and G​emma 4 12B on the same harness at the same effort would replace the Index-only comparison above with something subtractable, and the fact that Beam's weights are now public means anyone can run it. A published price for Beam's API — or for a hosted FP8 or NVFP4 deployment — would turn the cost section from a hardware argument into a rate card. Until one of those lands, the accurate summary is this: the 40-to-1 parameter gap buys about 16 points of independently measured intelligence and a different set of benchmarks, and it costs you a place to put it.

A result like this is also a reminder that model mistakes are already documented: the AI incidents and agent failures behind models in this class are collected in the OrcaRouter AI Incident Archive, where each entry carries its own sources, severity, confidence grade and disputed flag.