What Aleph Alpha's Kolibri open-weight model means for builders

Most open-weight model launches follow the same script: a big parameter count, a wall of benchmarks, and a vague promise that it "runs anywhere." Aleph Alpha's new model, Kolibri, is more interesting than that, partly because of what it chose not to do.

Released on October 3, 2026, Germany's Day of Unity, Kolibri is an English and German Mixture-of-Experts (MoE) model with 78.1 billion total parameters, of which only about 3.46 billion are active for any given token. The weights are on Hugging Face under the Apache 2.0 license, ungated. And instead of trying to speak 100 languages, it goes deep on two.

If you build products for regulated industries, care about running models on your own hardware, or just want a capable open model that will not eat your GPU budget, this one is worth a look. Here is what is actually in the release and how I would think about it.

The short version

According to the Hugging Face model card and Aleph Alpha's launch post:

• Size: 78.1B total parameters, 3.46B active per token (about 4.4%).
• Context: native 262,144 tokens, validated up to 1,048,576 tokens. Aleph Alpha recommends staying at or below 262K for serving efficiency and complex tasks.
• Languages: German and English, by design.
• Features: a reasoning mode with four effort levels (none, low, medium, high) and tool calling.
• License: Apache 2.0 for the weights and config files.
• Hardware: roughly 78 GB in FP8. The minimum listed is 2x A100 80 GB, 2x H100 SXM5, 1x H200, 1x B200 or 1x B300.
• Knowledge cutoff: June 18, 2026, for both languages.

Aleph Alpha positions it for "sovereign mission-critical work in regulated areas including public administration, industrials and aerospace." In plain terms: organizations that cannot or will not send internal data to a third-party API.

How it is built, without the jargon overload

Lots of small experts, few of them awake at once

Kolibri has 50 layers. Each MoE layer contains 384 small "expert" networks plus one shared expert. For every token, a router picks just 6 of those 384 experts. That is why a 78B model can run with the per-token compute of a much smaller one.

The catch, which the model card states honestly, is memory. All 78B parameters still have to sit in GPU memory even though only a slice is active. So Kolibri is cheap to run per token, but not tiny to host.

Mostly local attention, with a few global layers

Only 10 of the 50 layers look across the whole context. The other 40 use a sliding window over the previous 512 tokens. Because those windowed layers keep a fixed-size cache, memory does not balloon as your prompt grows. Aleph Alpha says this is what keeps a 1M-token context affordable.

A tokenizer that understands German compounds

This is my favorite detail. German loves long compound words, and most tokenizers chop them into nonsense fragments. Aleph Alpha built a new tokenizer training method it calls UniBPE. Its launch post shows "Bundessozialgerichtes" (Federal Social Court, genitive) splitting cleanly into "Bundes / sozial / gericht / es," while other popular tokenizers cut it into fragments like "Bund / ess / oz / ial."

The practical payoff is fewer tokens for the same German text. On German web text, Kolibri averages 4.90 bytes per token, versus 4.35 for the GPT-5 tokenizer in Aleph Alpha's comparison. Fewer tokens means lower cost and faster responses for German-heavy workloads, without giving up much in English.

Real German data, not just translations

Aleph Alpha says more than a fifth of the pre-training tokens were German, and that it leaned on curated German web text and rephrased German documents rather than machine translation. Its argument is that translated text carries the cultural fingerprint of its source, so a model trained on it "speaks German about a world that looks American." The launch post's example: you want a model that knows about a chancellor, not a president.

How good is it?

All the numbers below are Aleph Alpha's own, run with its evaluation setup at reasoning effort "high." Treat them as a starting point and test on your own tasks.

• Overall average: 75.5 in English and 70.8 in German, the top scores among the MoE models Aleph Alpha compared, which include Qwen3.6 35B-A3B (71.4 / 67.3), Nemotron 3 Super 120B-A12B (73.0 / 67.9) and Mistral Small 4 (63.1 / 61.4).
• Math and science: 96.9 on AIME 2025, 96.0 on AIME 2026 and 84.3 on GPQA Diamond.
• Code: 85.9 on LiveCodeBench v6, 92.7 on HumanEval+ and 66.4 on SWE-Bench Verified.

It is not winning everywhere. The dense Qwen3.8 27B scores higher overall (80.2 English, 79.9 German), though it activates far more parameters per token. On the BFCL v4 function-calling benchmark, Kolibri scores 61.4 against 70.5 for Qwen3.5 35B-A3B. And on SWE-Bench Verified, Qwen3.6 35B-A3B posts 73.8. If heavy tool calling or agentic coding is your main use case, compare carefully.

It is trained to say "I don't know"

For anyone building retrieval-augmented generation (RAG) over company documents, this might matter more than any benchmark. Aleph Alpha trained Kolibri with abstention data and an in-house method it calls the Merlin-Arthur protocol. In simple terms, one "player" hides the evidence a question needs, and the model is rewarded for refusing to answer instead of guessing.

The company reports that Kolibri abstains instead of answering wrongly on 44% of AA-Omniscience items, compared with about 15% for its predecessor, Kolibri Origin. In regulated settings, a model that admits it does not know is often the difference between a pilot and a real deployment.

What this means for builders

1. "Small active, big total" is the efficient sweet spot right now

Kolibri is another sign that sparse MoE models are where open-weight efficiency is heading. For you, that means planning capacity around memory, not just compute. One H200 or B200, or a pair of H100s, can host it. Aleph Alpha says it chose 78B over a larger 123B variant because, on two H100s, the 78B model handles 18 concurrent 256K-token requests versus 3 for the bigger one, and decodes 28% faster.

2. If you serve German users, re-check your token bill

Tokenizer efficiency is a hidden cost. If a large share of your traffic is German, a tokenizer that needs fewer tokens per document directly cuts spend and latency. Run a sample of your real German prompts through Kolibri's tokenizer and your current model's tokenizer and compare.

3. Getting it running is straightforward, with one extra step

Kolibri needs Aleph Alpha's aleph-alpha-inference package, a vLLM plugin, or the provided container image. From the model card:

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-choice

That gives you an OpenAI-compatible endpoint. You can set reasoning_effort (none, low, medium, high) through chat_template_kwargs, and the recommended sampling settings are temperature 1.0, top_p 0.97 and top_k 128. Going past 262K tokens needs an extra --max-model-len flag and a config override.

4. Use the reasoning dial to control cost

Four effort levels let you route simple requests to "none" or "low" and save "high" for hard questions. Build that routing into your app from day one rather than running everything at maximum effort.

5. Read the license scope

The Apache 2.0 grant covers the published weights and configuration files. The model card is explicit that it does not extend to Aleph Alpha's training code, architecture, parameter settings or methods. For most teams deploying the model that is fine, but your legal team will want to know.

6. Keep a human in the loop

Aleph Alpha says Kolibri is meant for systems where a person reviews output before it is acted on, not fully autonomous agents. Its own guidance asks you to add content filtering and output validation at the application level. That is good practice for any model, and especially in the regulated sectors this one targets.

The bigger picture

Kolibri is a clear bet on specialization and sovereignty over size. Rather than chasing the largest general model, Aleph Alpha built something that is efficient to host, strong in one non-English language, transparent about training data, and designed with the EU AI Act and GDPR in mind. Whether or not you ever use it, expect more models like this: regional, domain-focused, open-weight, and built to run inside an organization's own walls.

FAQ

Is Kolibri free to use commercially? The weights and configuration files are released under Apache 2.0, which allows commercial use. The license does not cover Aleph Alpha's training code or methods.

What hardware do I need? About 78 GB of GPU memory for the FP8 weights. The model card lists a minimum of 2x A100 80 GB, 2x H100 SXM5, 1x H200, 1x B200 or 1x B300.

Does it only work in German? No. It is bilingual by design and performs strongly in English, but it is not built for other languages.

Can it really handle 1 million tokens? Aleph Alpha says it validated quality and serving efficiency up to 1,048,576 tokens, but recommends 262,144 or fewer for latency-sensitive work and complex tasks.

Who is it best for? Teams that need on-premises or sovereign deployment, German-language workloads, or grounded RAG over internal documents, especially in public sector, industrial and aerospace settings.

Sources: Aleph Alpha's launch post (Oct 3, 2026), the Kolibri-1 model card on Hugging Face, Aleph Alpha's technical report and MarkTechPost.