Kolibri

05 Oct 2026

Aleph-Alpha/Kolibri-1

Aleph Alpha's mixture-of-experts reasoning model for German and English

https://huggingface.co/Aleph-Alpha/Kolibri-1

Kolibri is a large language model built end to end in Europe. Aleph Alpha, from Heidelberg, curated the data, trained the model on GPUs in Germany and Finland, and released the weights openly on 3rd October 2026 under the Apache 2.0 licence. It focuses on 2 languages, German and English, and on cheap serving: of its 78 billion parameters, only about 3.5 billion work on each token.

It's aimed at regulated work: public administration, industry, aerospace. That's where "where was this built, and who controls it" matters as much as the benchmark score.

What makes it different

• Built in Europe, under European law. Trained on 768 NVIDIA B200 GPUs in Germany and Finland, by a German team that owns the whole pipeline from data to optimisation. The company says there's "no foreign control".
• German as a first language, not a translation. 23.9% of the pre-training data is German (per the model card), mostly original German text rather than machine translation.
• Cheap per token. Only 3.5B parameters are active per token, so it runs fast for its quality. The catch: all 78B must sit in memory.
• Long documents. Most attention layers look at nearby text, a few look across the whole context. That keeps a 1M-token context affordable.
• Transparent. The model card documents the training data mix, the compute and the energy: about 950 MWh for pre-training and long-context training.

For business people

The problem: many European organisations can't, or won't, send sensitive documents to a US model. The open alternatives mostly come from China or the US, and their training data is a black box.

What Kolibri offers: a capable model with a European chain of custody. You can run it on your own servers or a European cloud, inspect the weights, and point regulators to a documented training process.

Where it fits:

• Document work: drafting, summarising and extracting from long German or English files.
• Question answering over your own material, with retrieval.
• Agents: calling tools and APIs, with a person reviewing the output. Aleph Alpha positions it as an advisor, not as the component that decides.

How good is it? On Aleph Alpha's own overall scores, Kolibri reaches 75.5 in English and 70.8 in German, the best of the small-active-parameter models it compares, ahead of Qwen3.5 35B-A3B (74.7 and 69.8). Larger dense models still score higher: Qwen3.8 27B reaches 80.2 and 79.9. Aleph Alpha also reports 96.9 on the AIME 2025 maths test and 84.3 on GPQA Diamond.

The limits:

• 2 languages only. Deliberately: depth over breadth. No French or Spanish focus.
• Big hardware. About 78 GB of memory for the weights. The minimum is a single H200 or B200, or 2 A100 or H100 GPUs.
• The scores are the maker's own, on its own evaluation set.

For technical people

Kolibri needs Aleph Alpha's vLLM plugin:

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

The server speaks the OpenAI API, so any OpenAI client works:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
response = client.chat.completions.create(
    model="Aleph-Alpha/Kolibri-1",
    messages=[{"role": "user", "content": "Fasse diesen Vertrag in 5 Punkten zusammen."}],
    extra_body={"chat_template_kwargs": {"reasoning_effort": "medium"}},
)
print(response.choices[0].message.content)

• Precision: FP8 weights in 128×128 blocks, with an FP8 key-value cache. Embeddings, output head, norms and router stay in BF16. A BF16 version is published separately.
• Attention: 4 sliding-window layers for every global layer. Positions are encoded only in the sliding-window layers, which is why the context can stretch past its training length.
• Training: 20 trillion tokens of pre-training (62.5% English, 23.9% German, 13.6% code), plus mid-training, long-context training, supervised fine-tuning and reinforcement learning. Optimiser: Muon.
• Sampling: Aleph Alpha recommends temperature 1.0, top_p 0.97 and top_k 128.
• Long context: add --max-model-len 1048576 and the matching --hf-overrides to go past 262,144 tokens, at a cost in speed.
• Tool calling: Hermes-style function calling through the standard tools field, combinable with reasoning.

Value

This is the model I'd point to in a sovereignty conversation with a German customer: trained in Europe, documented, open weights, Apache 2.0, and strong in German. It's the model-side answer to a European inference provider like SovInfra (see SovInfra ).

For my own setup, it doesn't fit yet. My NicAI model runs on Qwen3.8-27B in Ollama, and Kolibri ships for vLLM on data-centre GPUs, not as a local Mac model. If someone publishes a quantised version that runs on Apple Silicon, it would be worth a test on German writing, where most open models are weakest.

Kolibri vs Qwen3.8 27B, the base of NicAI

06 Oct 2026 a head-to-head with the model my NicAI voice model is built on: a LoRA fine-tune of Qwen3.8 27B on 11,321 of my own texts, served by Ollama on my Mac Studio (see Fine-tuning my own model (LLM): NicAI ).

The 2 models

The scores

From Aleph Alpha's own model card, which includes Qwen3.8 27B as a reference. Higher is better.

Qwen3.8 27B wins on nearly every row, German included, which is Kolibri's home ground. Kolibri wins where it says "I don't know": it sticks closer to the source and abstains more often. Aleph Alpha greys Qwen3.8 27B out in its table as a dense model: it activates about 8 times more parameters per token.

Could Kolibri replace Qwen as the NicAI base?

Not as a better voice model, and not today. 3 reasons:

1. Languages. I write in English, French and German. Kolibri is trained for German and English only, so my French texts would suffer most.
2. Quality on what matters for style. NicAI's job is to follow my writing rules and sound like me. Qwen3.8 27B scores higher on instruction following, and much higher in German.
3. The fine-tuning path doesn't exist yet on my Mac. I trained NicAI with mlx_lm.lora. For Kolibri:
   • Official tools: Aleph Alpha ships only a vLLM plugin for serving on NVIDIA GPUs. There's no official training code, and neither Hugging Face Transformers nor MLX supports the kolibri1 architecture out of the box.
   • Community ports: unofficial MLX conversions exist, for example velaia/Kolibri-1-MLX-4bit, with a ported kolibri1.py. Native support is proposed in mlx-lm pull request 1945, still open on 6th October 2026.
   • In principle: once mlx-lm supports the architecture, a QLoRA run on the 4-bit model (about 41 GB) would fit in my Mac Studio's 128 GB. It would be untested territory: LoRA on a 384-expert MoE behaves differently from a dense model, and nobody has published a Kolibri style fine-tune yet.
   • Full precision: the BF16 weights are about 156 GB, more than my Mac has, so anything beyond QLoRA means rented GPUs.

The 1 real argument for Kolibri is speed. With 3.5B active parameters, the community MLX port generates about 52 to 56 tokens per second on an M1 Max. NicAI on Qwen3.8 27B takes about 40 seconds for 3 candidate texts. A German-only voice model on Kolibri could be several times faster.

Verdict: keep Qwen3.8 27B as the NicAI base. Revisit Kolibri when mlx-lm supports it natively, and test it only as a fast German-and-English variant, with my existing evaluation set, before training anything.

This replaces what I wrote yesterday under Value, that Kolibri doesn't run on a Mac: community MLX ports appeared within days of the release.

Further Reading

Kolibri has landed: a sovereign open-weight model

Aleph Alpha's launch post: why it was built, benchmarks, sovereignty

https://aleph-alpha.com/en/blog/kolibri-has-landed-a-sovereign-open-weight-model/

Kolibri technical report

Architecture, training data, compute and evaluation in detail (PDF)

https://aleph-alpha.com/downloads/tech-report.pdf

Aleph-Alpha/aleph-alpha-inference

The vLLM plugin needed to serve Kolibri

https://github.com/Aleph-Alpha/aleph-alpha-inference