Western Open-Weight Models: Beam and Le Chonk

Reflection AI and Mistral shipped open-weight flagships a day apart in the first week of October, and both say they compare to the best China has to offer. 

Reflection’s Beam is a 501B-parameter workhorse that claims GLM-5.2-level reasoning, a bar Z.ai has already raised with GLM-5.3, on a fraction of the inference compute. Mistral’s Large 4, which the company nicknamed “le Chonk,” is a 1-trillion-parameter flagship built, trained, and served in Europe. 

Chinese labs still set the bar on price per capability, and neither launch moves it. On Artificial Analysis’s open-weights index, Le Chonk scores 38 against 46 for MiMo-V2.6-Pro and 45 for GLM-5.3. 

So the Western pitch rests on four other questions: where the model runs, who operates it, which license applies, and what each answer costs. Let’s explore this in more detail.

At A Glance: Beam, Le Chonk, And The Bar They’re Chasing

Here’s each launch next to its named Chinese rivals and the strongest US open model in production. Beam and Le Chonk rows are launch-day promises. 

The Price-Per-Capability Bar Chinese Labs Set

For the last year and a half, the open-weight frontier has been Chinese. Nathan Lambert’s Interconnects dates the clear Chinese lead to around April 2025, and Hugging Face’s summer 2026 state of open models found that this year’s releases above 100B parameters were built on Chinese models or used Chinese-lab artifacts.

Chinese labs also paired strong models with aggressive pricing. On Artificial Analysis’s open-weights leaderboard (Intelligence Index v4.3.2), MiMo-V2.6-Pro scores 46, GLM-5.3 scores 45, Kimi K3 scores 44, and GLM-5.3-Flash scores 42. The best US entries on that leaderboard are Inkling at 25 and Nemotron 3 Ultra at 23. Le Chonk lands at 38 on its own Artificial Analysis page, and AA’s launch analysis calls it the “most intelligent model from outside the US and China.”

Here they are against output price.

The upper-left corner belongs to China. GLM-5.3-Flash scores 42 at $0.50 per million output tokens on DeepInfra, and the Western models score lower at higher prices. Beam is missing because it has no data on either axis yet. Artificial Analysis hasn’t scored it, and Reflection hasn’t published pricing. On benchmark per dollar alone, it’s easy to see why both labs chose to argue about something else. (We covered the broader open vs closed version of this trade-off separately.)

Beam: A Workhorse Sold On Compute Per Answer

Reflection’s launch post concedes that Kimi K3 remains ahead on raw capability, so it sells Beam on efficiency instead. Beam, it says, “achieves scores comparable to GLM-5.2 while using 3–4× less inference compute.” Beam is a text-only mixture-of-experts (MoE) model with 501B total parameters and 23B active per token, pretrained on 23.8T tokens across 6,144 NVIDIA GB300 GPUs.

Read the footnote before you quote that number. Reflection defines generation compute as roughly 2 × active parameters × mean generated tokens per attempt, counting reasoning plus the final answer. That makes it an estimate, and its first factor is easy to chart:

Beam’s 23B active parameters (highlighted) against GLM-5.2’s roughly 40B give it about a 1.7x edge per token. DeepSeek V4.1 Flash and GLM-5.3-Flash are leaner still. To reach 3-4x, the remainder has to come from Beam generating fewer tokens per answer. Artificial Analysis, which had early access, said Beam looks like “one of the most token-efficient open models we’ve seen for its level of intelligence.” Here’s the arithmetic:

def decode_flops(active_params_b: float, generated_tokens: int) -> float:
    """Reflection's proxy: 2 x active params x generated tokens (decode only)."""
    return 2 * active_params_b * 1e9 * generated_tokens

# Active parameters, in billions
BEAM, GLM_5_2 = 23, 40

param_ratio = GLM_5_2 / BEAM
print(f"Per-token advantage from active params: {param_ratio:.2f}x")

# What token ratio would close the gap to Reflection's 3-4x claim?
for claimed in (3.0, 4.0):
    implied = claimed / param_ratio
    print(f"{claimed:.0f}x total implies GLM-5.2 writes {implied:.2f}x more tokens per answer")

# Sanity check with a hypothetical 6,000-token reasoning trace
print(f"Beam, 6k tokens: {decode_flops(BEAM, 6_000) / 1e12:.0f} TFLOPs")
copy

So GLM-5.2 would need to write roughly 1.7x to 2.3x more output tokens for the same result. Does Beam actually reason that briefly? That’s unverified until the weights ship and independent evaluators measure its output length. Once it’s callable, test the claim on your own prompts. The formula also leaves out the costs that dominate agent workloads.

Prefill is the big one. An agent loop that re-reads a 100K-token context on every tool call spends most of its compute reading, and the 3-4x number says nothing about that phase. All 501B parameters also have to sit in GPU memory even though only 23B fire per token. Cost per finished task tracks turns and tokens more than per-token price, as we argued in small open-weight models’ hidden cost advantage.

Le Chonk: A Flagship Sold On Where It Runs

Mistral went the other way. Mistral Large 4 is a 1.05T-parameter MoE with 49B active per token (52B if you count embeddings and output layers, per its Hugging Face card). It takes text and image input across more than 160 languages, and Mistral says it significantly outperforms “any open-weight model developed in the US or Europe.” On specs, plan around what is served, not what is printed: Mistral’s docs list a 1M-token context window, but Artificial Analysis lists roughly 512K for the preview API it tested, and Beam’s beta API caps requests at 256K against a claimed 1M.

The headline is jurisdiction. Mistral says Large 4 was trained from scratch on 3,800 NVIDIA Grace Blackwell GPUs in its own European datacenters, and the preview is served on the same hardware. It will run in “a European deployment that Mistral operates end-to-end, independently of other digital service providers and under European law,” and for security work it can run on private cloud or on-premise. Guillaume Lample put the reasoning bluntly to WIRED: “If you use a closed model, there is no guarantee it will still be there tomorrow.”

Think of it as a ladder, where each rung moves the model closer to hardware you control.

Today Le Chonk sits on the bottom two rungs, and the top two depend on a license Mistral hasn’t named. The capability is real but  . Artificial Analysis measured $1.13 per Intelligence Index task at list price, more than 4x what higher-scored open models like GLM-5.3-Flash cost, partly because Large 4 produced 200M output tokens to finish the index against a median of 82M. The data sovereignty case for open weights only pays off once you can actually climb the ladder. Both launches also lack independent serving numbers. No measured latency, throughput, or time to first token under load exists for Beam or Large 4, so the ladder assesses where a model can run; how well it serves stays unknown until weights ship and providers publish measurements.

Reading The Scoreboard

Both launch posts carry vendor-reported benchmarks. Reflection’s is more complete, and it includes competitors its headline skips. Below is a subset of Reflection’s published numbers as of October 8 (Beam’s scores were revised that day). Competitor scores are Reflection’s compilation from third-party leaderboards, so read the table as claimed scores against the baselines Reflection chose. Bold marks the row leader, and NR means not reported.

Source: reflection.ai/beam, all scores vendor-reported.

Within that chosen set, Beam beats the two US models, Inkling and Nemotron 3 Ultra, on every shared row, and those are also the table’s two weakest models. GLM-5.2, the model in Reflection’s headline, is no longer Z.ai’s flagship. GLM-5.3 shipped in late August and leads Beam on every row where both report. Mistral reports Large 4 at 61.7% on DeepSWE v1.1, level with the 61.0 Reflection’s table prints for GLM-5.3, but VentureBeat points out that the live leaderboard has Kimi K3 and GLM-5.3 nearer 69%. Treat both vendors’ tables as dated snapshots of a moving leaderboard. For more on the Chinese side, see our Kimi K3 vs DeepSeek V4 Pro vs GLM-5.2 comparison.

Le Chonk’s numbers live on a different scoreboard, since what exists for it is Mistral’s own claims plus Artificial Analysis’s independent measurements:

Sources: Artificial Analysis’s model page and launch analysis, Mistral’s launch post, VentureBeat. Read the two tables together and the picture is the same from both launches: neither Western flagship beats GLM-5.3 on a scale anyone else can check.

The Rest Of The Western Open-Weight Bench

Several other Western options are deployable today. None matches GLM-5.3 on capability, but several win on license and price.

Inkling is the closest thing to a Western Beam that you can call right now. It’s a 975B MoE under Apache 2.0, and it accepts audio, which neither Beam nor Le Chonk does. Nemotron 3 Ultra’s selling point is openness beyond the weights, since NVIDIA released training data and recipes alongside the checkpoints. At the cheap end, gpt-oss-120b and Nemotron 3 Super are the grunt-work picks. At $0.17 and $0.40 per million output tokens, frontier capability stops mattering for triage and routing steps.

Licensing Is Where Western Open-Weight Models Can Win

Scan the license columns and the Chinese flagships are drifting toward custom terms. GLM-5.2 shipped under plain MIT, but GLM-5.3 moved to its own license, which requires companies above $10B in revenue to pass Z.ai’s security review before offering it as a hosted service. Kimi K3 and Qwen3.8-Max ship under their own named licenses with commercial conditions. DeepSeek is the holdout, still on MIT.

The Western side is moving the other way, at least at Reflection. Beam’s weights are promised under Apache 2.0, which matches Inkling, gpt-oss-120b, and Gemma 4. That’s the license legal teams approve without a meeting. Mistral is the open question. Its previous flagship, Mistral Large 3, was Apache 2.0, but its most recent mid-size release, Medium 3.5, uses a modified MIT license that excludes companies with more than $20M in monthly revenue. Large 4’s Hugging Face page has no license field at all.

Axios also notes that the FY2026 NDAA directs the Defense Department to remove DeepSeek from government and contractor systems, and that Western releases give businesses alternatives to Chinese options they may have eschewed for security reasons. Reflection CEO Misha Laskin told Axios: “Once you’re spending that amount on intelligence, you want to move from renting it to owning it yourself.”

Three different risks hide inside the word “origin”.

• Serving location is whose datacenter processes your prompts: every model you can call on DeepInfra today, Chinese-origin or not, runs in US data centers with zero retention, which covers most data-handling concerns.
• Weights origin is who built the model and what its license permits, which drives legal exposure and what you can change.
• Statutory procurement is the narrowest case and the only one where origin is disqualifying by itself: if the NDAA or a customer contract excludes Chinese-origin weights, no amount of US serving changes that, and Beam, Le Chonk, Inkling, Nemotron, and gpt-oss are your choices.

If statutory procurement isn’t your situation, the Chinese flagships earn their place on price per capability. The same split answers the obvious question about Le Chonk: if you need it under European law specifically, that path runs through Mistral’s own EU deployment or self-hosting once the weights ship; a US inference provider can’t offer European jurisdiction.

Running Western Open-Weight Models On Deepinfra Today

You don’t need to wait for either launch to build the plumbing. Make model choice a policy decision in code, so origin and license sit next to price in one place. DeepInfra serves a huge collection of models through one OpenAI-compatible endpoint, so the policy is just a list of model IDs.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPINFRA_API_TOKEN"],
    base_url="https://api.deepinfra.com/v1/openai",
)

# Candidates per role, tagged with origin and license.
# Add Beam or Mistral Large 4 here once a provider serves their weights.
CATALOG = {
    "agent": [
        ("thinkingmachines/Inkling", "US", "apache-2.0"),
        ("nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B", "US", "openmdw-1.1"),
        ("zai-org/GLM-5.3", "CN", "glm-5.3"),
    ],
    "triage": [
        ("openai/gpt-oss-120b", "US", "apache-2.0"),
        ("deepseek-ai/DeepSeek-V4.1-Flash", "CN", "mit"),
    ],
}

POLICY = {"origins": {"US", "EU"}, "licenses": {"apache-2.0", "openmdw-1.1", "mit"}}


def allowed(role: str) -> list[str]:
    return [
        model for model, origin, license_id in CATALOG[role]
        if origin in POLICY["origins"] and license_id in POLICY["licenses"]
    ]


def complete(role: str, messages: list[dict]) -> str:
    last_error = None
    for model in allowed(role):  # first allowed model wins, the rest are fallbacks
        try:
            resp = client.chat.completions.create(model=model, messages=messages, timeout=60)
            return resp.choices[0].message.content
        except Exception as err:
            last_error = err
    raise RuntimeError(f"No allowed model succeeded for role {role!r}") from last_error


print(complete("triage", [{"role": "user", "content": "Classify: 'refund not received'"}]))
copy

Loosen POLICY and GLM-5.3 joins the agent pool. When Beam’s weights land, it’s one more tuple.

Next, build a token-efficiency check, since Beam’s argument rests on generated tokens per answer. Run one prompt set across candidates and record what each wrote:

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key=os.environ["DEEPINFRA_API_TOKEN"],
    base_url="https://api.deepinfra.com/v1/openai",
)

# (model id, active params in billions, $ per 1M input, $ per 1M output)
CANDIDATES = [
    ("thinkingmachines/Inkling", 41, 0.95, 4.05),
    ("nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B", 55, 0.50, 2.20),
    ("zai-org/GLM-5.3", 40, 0.90, 4.00),
]

PROMPT = [{"role": "user", "content": "Find the bug: def avg(xs): return sum(xs) / len(xs) - 1"}]


async def measure(model: str, active_b: float, price_in: float, price_out: float) -> dict:
    resp = await client.chat.completions.create(model=model, messages=PROMPT)
    u = resp.usage
    return {
        "model": model.split("/")[-1],
        "out_tokens": u.completion_tokens,
        "decode_tflops": 2 * active_b * 1e9 * u.completion_tokens / 1e12,
        "cost_usd": (u.prompt_tokens * price_in + u.completion_tokens * price_out) / 1e6,
    }


async def main():
    rows = await asyncio.gather(*(measure(*c) for c in CANDIDATES))
    for r in sorted(rows, key=lambda r: r["cost_usd"]):
        print(f"{r['model']:<40} {r['out_tokens']:>6} tok  {r['decode_tflops']:>7.1f} TFLOPs  ${r['cost_usd']:.5f}")


asyncio.run(main())
copy

Run it over a few hundred real prompts and you get Reflection’s proxy, measured on your workload. When Beam is callable, add a row and see whether the 3-4x survives contact with your traffic.

Everything here runs on DeepInfra’s pay-as-you-go pricing with no contract, on zero-retention US infrastructure with SOC 2 and ISO 27001 certification.

Conclusion

Neither Beam nor Le Chonk closes the gap with the best Chinese open models. Reflection’s own table shows that, and so does Artificial Analysis. They change the terms of the comparison instead. The split is almost tidy: Beam, sold on writing fewer tokens per answer, argues compute per answer and an Apache 2.0 license, while Le Chonk, which burned 200M output tokens finishing Artificial Analysis’s index, argues European operation and on-prem control. Inkling, the Nemotron 3 models, and gpt-oss-120b are already competing on permissive licensing and price. If your procurement rules exclude Chinese-origin weights, that’s a real menu for the first time, and it grows when the weights land.

Start with the models you can run today on DeepInfra’s model catalog, wire up the routing policy, and the new Western open-weight models become one-line additions. Questions about any of these models? Reach us at feedback@deepinfra.com, join our Discord, or find us on X at @DeepInfra.

FAQ

Is Reflection Beam available on DeepInfra?

Not yet. As of launch, Beam was available only through a waitlist beta on Reflection’s own OpenAI-compatible API, and its Hugging Face organization had no public models. Reflection has promised Apache 2.0 weights later in October, and inference providers can host the model once those ship. Until then, the closest Western MoE on DeepInfra is Inkling.

When will Mistral Large 4 weights be released, and under what license?

Mistral says by the end of October, and its Hugging Face page lists an October 31 ETA. Mistral hasn’t announced a license, and its recent releases don’t settle the question, so check the LICENSE file before planning a self-hosted deployment.

Is Beam actually 3-4x cheaper to run than GLM-5.2?

Not necessarily in dollars. The 3-4x figure estimates decode compute alone, and Reflection hasn’t published pricing, so dollar cost is unknown. The token-efficiency check in the code section above measures it on your traffic.