Three open-weight language models were announced in four days. On October 3, 2026 — the Day of German Unity — Aleph Alpha released Kolibri, a German-English model. On October 5, Reflection AI announced Beam, a 501-billion-parameter model. On October 6, Mistral AI launched Mistral Large 4, a trillion-parameter model it calls “le Chonk”. Searches for open-weight and self-hosted models were already climbing before that week, so the question now is short: which one do I run on my own GPUs?
The honest answer starts with two corrections. These aren’t three rivals — they are three weight classes, and the smallest activates fifteen times fewer parameters per token than the largest. And on October 12, only one of the three can actually be downloaded. This comparison works through what each vendor has published: release status, licenses, architecture, every benchmark at least two of them report, the memory each model needs, and what “sovereign” means for each.

Mistral Large 4 vs Kolibri vs Beam at a Glance
The figures come from Mistral’s announcement and model page, Aleph Alpha’s announcement and Kolibri model card, and Reflection’s Beam announcement.
| Mistral Large 4 | Kolibri | Beam | |
|---|---|---|---|
| Vendor | Mistral AI (France) | Aleph Alpha (Germany) | Reflection AI (USA) |
| Announced | October 6, 2026 | October 3, 2026 | October 5, 2026 |
| Weights | “By the end of the month” | On Hugging Face now | “Later this month” |
| License | Not published yet | Apache 2.0 | Apache 2.0 (announced) |
| How to use it today | API public preview | Self-host | Early-access waitlist |
| Architecture | Mixture-of-experts | Mixture-of-experts, 384 experts | Sparse mixture-of-experts |
| Total parameters | ~1.05T (plus a 1.6B vision encoder) | 78.1B | 501B |
| Active parameters per token | 52B | 3.46B | 23B |
| Input | Text and images | Text | Text |
| Context window | 1M (API) | 262,144 native, 1,048,576 validated | 1M “effective” |
| Languages | 160+, all official EU languages | German and English | Not specified |
| Reasoning control | Hybrid instruct and reasoning | Effort none / low / medium / high |
Reasoning-effort parameter |
| Pre-training tokens | Not published | 20T (+3.44T mid-training) | 23.8T |
| Trained on | 3,800 NVIDIA Grace Blackwell GPUs, Mistral’s own European data centers | 768 B200 GPUs in Germany and Finland | 6,144 GB300 GPUs (pre-training), 10.5K GB300 (RL) |
| API price per million tokens | $1.36 input · $4.18 output | No public API price | Not published |
| Built for | Coding, agents, multimodal, cybersecurity | German and English enterprise and public sector | Coding and agentic workloads |
Three rows decide most choices before any benchmark:
- Weights. If you need a self-hosted model in production this month, the comparison is over: Kolibri is the only one you can download.
- Active parameters. They set the cost per token — 3.46B, 23B and 52B are three different GPU budgets.
- Input. Mistral Large 4 is the only one of the three that reads images, so scanned PDFs, charts and engineering drawings rule out the other two.
These aren’t three rivals. Kolibri is a German workhorse that fits on one GPU, Beam is a coding model for a multi-GPU node, and Mistral Large 4 is a frontier-class model for a full eight-GPU Blackwell server — and only Kolibri’s weights exist today.
Only One of the Three Is Downloadable Today
“Open-weight” covers three different states this month:
- Kolibri — released. The weights are on Hugging Face under Apache 2.0. The license covers the weights and configuration files in that repository; Aleph Alpha explicitly keeps the training code, architecture and methods.
- Beam — announced. Reflection says the model is “undergoing final red-teaming and evaluations” and will release “the weights, technical report, model card, and developer artifacts later this month” under Apache 2.0. Until then there is a waitlist.
- Mistral Large 4 — usable as a hosted preview. The API works today. Mistral says it will release the weights by the end of October and is red-teaming the model first with cybersecurity leaders, vetted partners and state authorities. The model page links a Hugging Face repository,
mistralai/Mistral-Large-4-1T-A52B, marked “Coming soon”, and lists no license.
Don’t plan a production rollout around a license nobody has read. Mistral has used different terms for different open models in the past, so wait for the actual license file before you assume Apache 2.0 for Mistral Large 4.
Mistral Large 4: Europe’s Trillion-Parameter Model
Mistral Large 4 is the largest model Mistral has built: a mixture-of-experts with about 1.05 trillion parameters, 52 billion active per token and a 1.6-billion-parameter vision encoder. Mistral calls it a hybrid instruct-and-reasoning model, so one model covers quick answers and longer reasoning. It was trained from scratch on 3,800 NVIDIA Grace Blackwell GPUs in Mistral’s own European data centers, and the preview runs on the same infrastructure.
What Mistral emphasizes:
- Coding and agents. 61.7% on DeepSWE v1.1, 59.4% on SWE-Atlas-QnA and 28.3% on Terminal-Bench 4, for a combined Coding Agent Index of 49.8% — ahead of DeepSeek V4 Pro and Qwen3.8 Max by Mistral’s numbers. On AutomationBench, 657 business workflows across apps like Gmail, Sheets and Salesforce, it scores 59.9%. In a blind coding-quality evaluation run with Surge AI it placed second of five models (3.74 out of 5), behind Claude Opus 5 (4.22) and ahead of Kimi K3 and GLM-5.3.
- Cybersecurity. Mistral reports that it ranks among the top five models worldwide on the Artificial Analysis Cyber Index, solves 93% of the 40 Cybench challenges, and scores 82% on a test that asks the model to reproduce a real vulnerability and patch it. On that test, Mistral says Claude Opus 5.5 and GPT-6 Astra score near zero because they refuse. For security teams, a model that does vulnerability work under your own policies is the real argument for self-hosting — and Mistral also reports a higher refusal rate on malicious cyber prompts than other open models.
- Images. Mistral Large 4 reads documents, charts and photos. On the Dense 200 visual-grounding test it reports 42% against GPT-6 Astra’s 41%.
- Languages. Its training data spans more than 160 languages, including every official language of the European Union.
- Prompt-injection robustness. It resists 93.3% of attacks on Lakera’s public B3 benchmark, the highest score Mistral saw among open models.
Pricing. The preview API lists $1.36 per million input tokens and $4.18 per million output tokens, with cached input at $0.14. When I checked on October 12, the model page showed a launch discount of half those prices. Mistral also runs a European deployment “end-to-end, independently of other digital service providers and under European law” — useful if you want the model before the weights arrive without sending data to a US hyperscaler.
What’s missing. No architecture details beyond the parameter counts, no pre-training token count, no German-specific scores, and no license. Mistral says the architecture, more benchmarks and the post-training method come with the weights.
Kolibri: A German Model That Fits on One GPU
Kolibri is Aleph Alpha’s answer to a narrower question: what is the best model for German and English enterprise work that a company can run on one server? It has 78.1 billion parameters but activates only 3.46 billion per token, spread over 384 small experts (six routed and one shared per token). Forty of its fifty layers look at a 512-token sliding window; every fifth layer sees the full context. That keeps memory per token bounded and makes long contexts cheap to serve.
Aleph Alpha explains the size decision with a serving number: in their tests a 123B version handled only 3 concurrent 256K-token requests on two H100s, while the 78B model handled 18 and decoded 28% faster.
What sets Kolibri apart:
- German by design. 21.3% of the pre-training tokens are German — about 4.3 trillion tokens, mostly organic or rephrased German web text plus parliamentary and legal documents. Machine translation was used sparingly. The bilingual tokenizer compresses German web text at 4.90 bytes per token, more than any other tokenizer in Aleph Alpha’s comparison — what that saves is shown below.
- It says “I don’t know”. Aleph Alpha trained Kolibri with abstention data and its Merlin-Arthur protocol. On the public AA-Omniscience set it abstains instead of answering wrong on 44% of items (its predecessor: 15%). For RAG over regulated documents, abstaining beats a confident guess.
- Vertical evaluations. Aleph Alpha built internal test suites for the German public sector, automotive suppliers, semiconductors, aerospace and industrial drive technology. On the German public-sector suite Kolibri scores 75.0.
- Strong for its weight class. In Aleph Alpha’s own comparison, Kolibri leads the mixture-of-experts models of similar size in both languages:
| Model (Aleph Alpha harness) | Active parameters | Overall (EN) | Overall (DE) |
|---|---|---|---|
| Kolibri | 3.5B | 75.5 | 70.8 |
| Qwen3.5 35B-A3B | 3B | 74.7 | 69.8 |
| GPT-OSS 120B | 5.1B | 72.3 | 70.2 |
| Nemotron 3 Super 120B-A12B | 12B | 73.0 | 67.9 |
| Mistral Small 4 119B-A6B | 6B | 63.1 | 61.4 |
| Qwen3.8 27B (dense) | 27B | 80.2 | 79.9 |
The dense Qwen3.8 27B still scores higher — at almost eight times the active parameters per token.
What German Text Costs in Tokens
The tokenizer difference is easy to underestimate. On the same German web text, Kolibri’s tokenizer packs 4.90 bytes into each token. Every other tokenizer in Aleph Alpha’s comparison needs more tokens for the same document: 13% more for GPT-5’s, 22% more for Tekken — the tokenizer of earlier Mistral models — 32% more for DeepSeek V4’s and 49% more for Kimi K3’s.

Tokens are what you pay for on an API, and what fills GPU memory and the context window when you self-host — so a German-heavy workload feels the difference on every request. On English text the gap disappears: the same tokenizers stay within about 3% of Kolibri, EuroLLM aside. Mistral hasn’t said whether Mistral Large 4 still uses Tekken, so read that row as a reference for Mistral’s earlier models, not a measurement of the new one.
Serving Kolibri needs Aleph Alpha’s vLLM plugin, which adds Kolibri’s reasoning and tool-call parsers:
pip install "aleph-alpha-inference>=1"
vllm serve Aleph-Alpha/Kolibri-1 --kv-cache-dtype fp8 \ --reasoning-parser kolibri1 \ --tool-call-parser kolibri1 \ --enable-auto-tool-choiceThe endpoint is OpenAI-compatible, so existing clients work; you set the reasoning effort through chat_template_kwargs. If you haven’t chosen an inference server yet, my vLLM vs Ollama comparison covers why a model like this belongs on vLLM rather than a desktop runtime.
The limits. Kolibri is text-only and bilingual by design — no French, Polish or Spanish. On hard agentic coding it trails bigger models: 27.7% on Terminal-Bench 2.1 against Beam’s 80.1% in the vendors’ own tables. And Aleph Alpha’s model card is explicit that Kolibri belongs in systems where a person reviews the output, not where the model makes the decision.
Beam: Reflection’s Coding Model
Beam is Reflection AI’s first public model, and it is built for one job: coding and agentic work. It is a sparse mixture-of-experts with 501 billion parameters, 23 billion active per token, 52 layers and interleaved local and global attention. It was pre-trained on 23.8 trillion tokens on 6,144 NVIDIA GB300 GPUs in under four weeks, then trained with reinforcement learning on 10.5K GB300 GPUs for another four weeks — more than 100 million rollouts across nearly a million coding, agentic and STEM environments.
Reflection’s own positioning is unusually candid: Beam is “competitive with larger open models like GLM 5.2 and approaching Qwen 3.8-Max on coding and agentic tasks”, while “frontier open models like Kimi K3 remain ahead on raw capability”. The pitch is efficiency — reasoning scores comparable to GLM-5.2 with three to four times less inference compute.
Beam’s reported scores, with the comparison models from Reflection’s own table:
| Benchmark | Beam | GLM 5.3 | Kimi K3 | Qwen 3.8 Max | DeepSeek V4.1 Flash |
|---|---|---|---|---|---|
| DeepSWE v1.1 | 44.4 | 61.0 | 68.0 | 51.0 | 74.2 |
| Terminal-Bench 2.1 | 80.1 | 88.2 | 88.3 | 86.6 | 90.6 |
| SWE-bench Verified | 80.9 | — | — | — | — |
| GPQA Diamond | 90.5 | 91.7 | 93.5 | 92.6 | 90.9 |
| Humanity’s Last Exam (no tools) | 36.2 | 42.3 | 46.9 | 43.6 | 39.1 |
| MCP Atlas | 78.7 | 84.2 | 82.3 | 84.5 | — |
Reflection updated these numbers on October 8, three days after launch.
The limits. Beam is text-only, the announcement says nothing about languages beyond code, and nobody outside the early-access group has run it. The sensible plan is to put Beam on your shortlist for coding agents and benchmark it the week the weights land.
Benchmarks: What You Can and Can’t Compare
No vendor published a table with all three models. Each ran its own evaluations, picked its own comparison models, and in some cases a different benchmark version. Mistral didn’t publish GPQA, HLE, SWE-bench or long-context scores at all — but the independent lab Artificial Analysis has already measured the Mistral Large 4 preview on Humanity’s Last Exam, AA-LCR and SciCode — benchmarks that Reflection, and for the first two also Aleph Alpha, report. With those filled in, here is every row that at least two of the three cover:
| Benchmark | Mistral Large 4 | Kolibri | Beam |
|---|---|---|---|
| Humanity’s Last Exam, no tools | 35.0¹ | 21.5 | 36.2 |
| AA-LCR (long context) | 81.3¹ | 68.3 | 79.3 |
| SciCode | 54.2¹ | — | 49.7 |
| DeepSWE v1.1 | 61.7 | — | 44.4 |
| SWE-bench Verified | — | 66.4 | 80.9 |
| Terminal-Bench 2.1 | — | 27.7 | 80.1 |
| GPQA Diamond | — | 84.3 | 90.5 |
| AIME 2026 | — | 96.0 | 97.8 |
| τ³-bench banking | — | 38.1 | 38.0 |
| IFBench | — | 78.1 | 79.7 |
| Active parameters per token | 52B | 3.5B | 23B |
¹ Measured by Artificial Analysis on the API preview. Every other number is vendor-reported on the vendor’s own harness. I searched the Mistral announcement, the model page and Aleph Alpha’s 189-page technical report for the empty cells — they aren’t published anywhere yet.

How to read it:
- Two rows now have all three. On Humanity’s Last Exam, Mistral Large 4 (35.0) and Beam (36.2) are close and Kolibri trails at 21.5. On long-context reasoning (AA-LCR), Mistral Large 4 leads with 81.3, Beam is close behind at 79.3 and Kolibri reaches 68.3 — with a fifteenth of Mistral’s active parameters.
- Beam beats Kolibri on seven of the eight rows they share — expected with almost seven times the active parameters. The gap is widest where long agentic loops matter (Terminal-Bench, SWE-bench) and smallest on AIME and IFBench.
- τ³-bench banking is the interesting tie. It’s an agentic customer-service benchmark in a regulated domain, and Kolibri matches Beam with about one-seventh of the active compute. If your workload looks like that, the small model may be enough.
- Mistral Large 4 vs Beam: four rows, Mistral ahead on three. DeepSWE (61.7 vs 44.4), SciCode (54.2 vs 49.7) and AA-LCR (81.3 vs 79.3); on HLE Beam is 1.2 points ahead. Reflection’s own table puts GLM 5.3 at 61.0 on DeepSWE — so Mistral Large 4 sits roughly at GLM 5.3’s level on that task.
- Mistral Large 4 vs Kolibri: two rows, both independent for Mistral. Mistral Large 4 leads clearly on both, as you’d expect at fifteen times the active parameters.
Putting All Three on One Scale
Beyond single benchmarks, Artificial Analysis scores the Mistral Large 4 preview at 38 on its Intelligence Index, above the median of 26 for comparable models, at an average of $1.13 per evaluation task. Kolibri and Beam aren’t on Artificial Analysis yet — but both vendors compared their models against models Artificial Analysis has measured, and that brackets them:
- Beam beats Inkling (index 25) on 13 of 15 rows in Reflection’s own table, beats GLM-5.2 (34) on 8 of 13 and loses to DeepSeek V4.1 Flash (39) on 7 of 9. That puts it roughly at GLM-5.2’s level, which matches Reflection’s own description.
- Kolibri averages above Qwen3.6 35B-A3B (18) and below the dense Qwen3.8 27B (34) in Aleph Alpha’s table.

A bracket is not a measurement: it assumes each vendor’s head-to-head would hold on an independent harness. But it is the first common scale for all three. Mistral Large 4 lands next to DeepSeek V4.1 Flash and a few points below the strongest open models — Kimi K3, GLM-5.3 and Qwen3.8 Max at 44–45. Beam probably lands somewhat below Mistral Large 4. Kolibri, with 3.5B active parameters, reaches at most the level of a dense 27B model. One more detail from the same page: Artificial Analysis lists the preview’s context window as 524K tokens, half the 1M on Mistral’s model page.
The practical reading is the same as for closed models: vendor tables tell you where to look, not what to buy. When I compared GPT-6.1 Sol and Claude Opus 5.5, the decisive numbers came from the price sheet, not the leaderboard. For self-hosted models, the decisive numbers come from your GPU budget.
Hardware: What Each Model Needs to Run
A mixture-of-experts model saves compute per token, not memory. Every expert has to sit in GPU memory because the router can pick any of them for the next token. So the memory you need follows total parameters, while the speed and cost per token follow active parameters.
For weights alone, the rule of thumb is parameters × bytes per parameter: 2 bytes at BF16, 1 byte at FP8, about half a byte at 4-bit.
| Kolibri | Beam | Mistral Large 4 | |
|---|---|---|---|
| Weights at FP8 | ~78 GB (published) | ~501 GB (estimate) | ~1.05 TB (estimate) |
| Weights at 4-bit | ~39 GB | ~250 GB | ~525 GB |
| Smallest sensible host | 1× H200 or 1× B200 | 4× B200 or 8× H200 | 8× B200 |
| On Google Cloud | A3 High with 2× H100 | A3 Ultra or A4, full node | A4, full node |
| Source | Aleph Alpha model card | My arithmetic | My arithmetic |

Three things the table hides:
- The KV cache comes on top. Long contexts need memory per request. Eight H100s (640 GB) fit Beam’s FP8 weights with about 140 GB left for the cache — enough to start, not enough for many long concurrent agents; four B200s (about 720 GB) leave a little more. Eight H200s (1,128 GB) fit Mistral Large 4’s FP8 weights with almost nothing left, which is why the table says B200.
- Kolibri’s architecture is built for this. With 40 of 50 layers on a 512-token window, its cache grows slowly with context length — that’s what lets one server handle 18 concurrent 256K-token requests.
- Quantization is the escape hatch. 4-bit weights halve the memory and usually cost some quality. Community quantizations of Kolibri are already on Hugging Face. How that trade-off works is in Quantization Explained — and for Beam and Mistral Large 4, wait for official formats before you plan hardware.
The numbers for Beam and Mistral Large 4 are my estimates from parameter counts. Neither vendor has published serving requirements; update the plan when the model cards ship.
Sovereignty: Jurisdiction, Ownership and the EU AI Act
All three vendors sell sovereignty, and each means something slightly different by it.
- Mistral AI trained the model in its own European data centers and offers a European deployment it runs “end-to-end, independently of other digital service providers and under European law”. It just raised a €3 billion Series D to build more of that capacity.
- Aleph Alpha says Kolibri was built in Germany and trained on infrastructure in Germany and Finland “under European and German law, with no foreign control”. But on September 16, 2026, Aleph Alpha and Canada’s Cohere signed a business combination agreement: the combined company will operate as Cohere, with planned headquarters in Berlin and Toronto. The deal still needs regulatory approval.
- Reflection AI is a US company. On October 10, the Financial Times reported that Nvidia is in talks to acquire or deepen its investment in Reflection AI.
What this means in practice: once Apache 2.0 weights run on your own hardware, no vendor sees your prompts, and a change of ownership can’t revoke the license on weights you already have. What a new owner can change is everything around the weights — support contracts, the hosted API, and whether there’s a next version. If you’re building a sovereign platform, treat the model like any other dependency: pin the version, mirror the weights into your own registry, and don’t depend on the vendor being reachable.
The EU AI Act. The obligations for general-purpose AI models apply to the providers — Mistral, Aleph Alpha and Reflection — and all three are on the European Commission’s list of signatories of the General-Purpose AI Code of Practice. Models with more than 10^25 FLOPs of training compute are presumed to carry systemic risk and face extra duties. Aleph Alpha publishes Kolibri’s pre-training compute — 6.4 × 10^23 FLOPs, well below that line. Mistral and Reflection haven’t published theirs.
None of that transfers to you automatically. Your obligations as a deployer follow your use case: a high-risk application under the AI Act brings duties whichever of the three models runs underneath, and a low-risk internal assistant brings few. Picking a European vendor doesn’t replace that assessment.
Which One Should You Self-Host?

- You need a self-hosted model in production this month: Kolibri — it’s the only one with published weights and a license.
- German documents, RAG, public sector or regulated industry, one or two GPUs: Kolibri. The German tokenizer, the abstention training and the vertical evaluations are aimed at exactly this, and pair it with a self-hosted embedding model to keep the whole pipeline in-house.
- Scanned documents, charts, many EU languages: Mistral Large 4 — use the API’s European deployment now, plan a B200-class node for when the weights land.
- Security operations — vulnerability triage, malware analysis, detection rules: Mistral Large 4, the only one of the three with published cybersecurity results.
- An internal coding-agent platform with a multi-GPU node to spare: put Beam and Mistral Large 4 on the shortlist and benchmark both on your own repositories the week their weights ship. Beam is cheaper per token; Mistral Large 4 scored higher on both coding benchmarks with a score for each (DeepSWE and SciCode).
Whichever you pick, run your own evaluation: your documents, your languages, your tools, and cost per completed task — not tokens per second on a vendor slide.
The Bottom Line
October’s open-weight wave gives European companies real options, but not interchangeable ones. Kolibri is a small, efficient German-English model you can run on one GPU today. Beam is a mid-sized American coding model that needs a multi-GPU node and doesn’t exist outside a waitlist yet. Mistral Large 4 is the most capable of the three on paper, the only multimodal one, and the biggest to host — usable today through an API, self-hostable once the weights and license arrive.
Decide in this order: what you can download, what your GPUs can hold, then what the benchmarks say. Revisit the comparison at the end of October, when two of the three model cards should finally exist.






From the community
Discussion on Mastodon & Bluesky
Replies to this article from the open web, pulled in live. No ads, no tracking scripts.
Reply there — it shows up here automatically.