Kolibri: Aleph Alpha's open German-English MoE model with 78B parameters
Kolibri is an English-German mixture-of-experts model with 78.1B parameters, of which only 3.46B are active per token. It's available as open weights under Apache 2.0 and aimed at sovereign deployments in government, industry and aviation. According to the report, it sits on the Pareto frontier for quality and running costs.

What this is about
Kolibri is an English-German language model that, according to its technical report, is being released as open weights under the Apache 2.0 license. Per alphaXiv's AI summary, Aleph Alpha is behind the report. The model is built for "sovereign" and specialized use, with a focus on German and regulated sectors such as public administration, industry and aviation. The authors stress that they control the entire development process: data, architecture, training infrastructure, post-training and evaluation. The sources don't give a link to the weights, so a Hugging Face repo is unknown.
Architecture: lots of capacity, little compute
Kolibri is a mixture-of-experts (MoE) model: each token passes only through selected expert networks instead of all parameters. In total there are 78.1B parameters (roughly, the knobs learned during training), but only 3.46B are active per token, or 4.4%. Each MoE layer picks six of 384 routed experts and also uses one shared expert.
A controlled sparsity test held active parameters at about 3.4B and varied the total size. Going from 42.1B to 82.3B, all quality metrics improved. From 82.3B to 122.6B, they improved only slightly. In decoding, the 82.3B and 122.6B variants were 13% and 32% slower than the smallest at 4k context, and 4% and 12% slower at 256k context. On two H100 GPUs, the 122.6B variant fit three concurrent requests with 256k tokens, while the 82.3B variant fit 18. The authors therefore aimed for around 80B total parameters.
The second building block is hybrid attention: 10 blocks with full attention and 40 with sliding-window attention over the preceding 512 tokens. In a proxy comparison at equal training compute, the authors say long-context scores improved with no loss on pre-training benchmarks. However, the compared models also differed in training length and positional encoding.
Training
The model was trained on 24 trillion tokens across pre-training, mid-training and context extension. German accounts for more than 20%. To reach that share, more than 2 trillion German tokens were added to existing German datasets, drawn from a custom web curation pipeline and synthetic generation. Post-training combines supervised fine-tuning on curated German and English data with reinforcement learning on over 1.2 million internally curated tasks (reasoning, tool use, instruction following, code, retrieval).
Kolibri builds on Kolibri Origin, an earlier iteration that validated the pipeline at scale. Both come from the "Model Factory," which links data, experiments, training, evaluation and deployment through versioned workflows. This is meant to ensure traceability and repeatability, and it was designed with regulation in mind. According to alphaXiv, though, it comes with no certification or guarantee for the behavior of downstream systems.
Results
| Comparison | Kolibri Origin | Kolibri |
|---|---|---|
| English overall | 54.1% | 75.5% |
| German overall | 46.4% | 70.8% |
| Throughput | – | 2.7× |
"Overall" is the unweighted mean of the category averages. English averages eight categories, and German averages the four categories with German benchmarks. Throughput was measured on eight B200 GPUs at 16k context, in UTF-8 bytes per second per GPU, with FP8 weights and KV cache. The baselines' quality scores mostly come from BF16 checkpoints. This is a proxy for high concurrency, not a measure of latency, total cost or energy use.
Among the open models tested, Kolibri sits on the Pareto frontier: no model offers higher quality at the same throughput or higher throughput at the same quality. Compared with Qwen3.5 35B-A3B (3B active), Kolibri scores 0.8 points higher in English and 1.0 in German. Both sit on the frontier. The dense 27B Qwen3.8 scores higher overall, but activates almost eight times as many parameters.
What you need to try it
The sources list no requirements for end users. As a rough estimate, 78.1B parameters need about 45–50 GB of memory at 4-bit quantization. That means several consumer GPUs or lots of system RAM with offloading. With only 3.46B active parameters, generation is relatively fast, provided the weights sit in RAM. The report's benchmarks ran on B200 and H100 servers.
Our take
Kolibri is a rare open model with an explicit German focus under a permissive license. That matters for public agencies and industry with privacy and sovereignty requirements. The efficient MoE design targets running costs. Some caveats remain: all figures come from the report itself, and the gain over Kolibri Origin has no single cause, since many stages changed at once. The Pareto claim holds only for the selected models and the chosen measurement setup, and stronger dense models like Qwen3.8 score better overall. Whether the model delivers in practice is for independent tests to show.
Sources
- arXiv cs.CL arxiv.org
- alphaxiv.org alphaxiv.org
Try it yourself: Kolibri
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
Kolibri is an assistant model from Aleph Alpha for German and English. You can chat with it, draft texts, summarize documents, pull data out of text (structured extraction) and write code. It can also "think" before answering (reasoning mode) and call external tools (tool calling), such as a search or a weather lookup. The model is a mixture-of-experts (MoE) model: it has 78B parameters but uses only 3.46B per token. That makes text output fast, but your memory still has to hold the whole model. The context is large: the Model Card recommends up to 262,144 tokens, and it was tested up to just over 1 million tokens. In comparison, Kolibri sits on the Pareto frontier (the best mix of quality and speed) among the open models tested, according to the vendor. The dense 27B Qwen3.8 scores higher overall. All figures come from the vendor, and independent tests are still missing. The model is meant as an aid: a human should check its outputs before acting on them.
Who is it worth it for?
Interesting for developers, tinkerers with plenty of hardware, and teams in government, industry or research who want to run an open model (Apache 2.0) with strong German themselves. Probably not for casual users with a normal home PC: the weights alone need about 78 GB according to the Model Card. In that case, smaller models or hosted access make more sense.
Ideas: What you can do with it
You paste a notice or official letter into the chat and ask for a summary in plain language. The result is a few sentences plus a list of deadlines and next steps. Afterwards, check the deadlines against the original.
You give the occasion, recipient and tone, such as a request for a deadline extension. The model produces a draft that you adapt. The focus on German helps with salutations and bureaucratic phrasing.
With retrieval-augmented generation, you pull relevant passages from your files and give them to the model along with your question. It answers based on those passages. That suits manuals, wikis or contracts, without data leaving the company.
Thanks to the large context, you can load whole reports or several documents at once. You then ask about contradictions, key points or an outline. For good quality, stay within 262,144 tokens.
You have it write small scripts, interpret error messages or comment code. For tricky cases, turn on reasoning. Always test the code yourself.
With tool calling, you describe functions such as a weather lookup or a database search. The model decides when to call them and writes the answer from the result. Your program should check the results before acting on them.
What your computer needs
Which variant is right for me?
Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.
| Variant | Download | Needs approx. | Compatible graphics cards |
|---|---|---|---|
Q2_K |
29 GB | 32 GB | e.g. 2× RTX 3090/4090 or RTX A6000 |
Q3_K_M |
38 GB | 42 GB | e.g. 2× RTX 3090/4090 or RTX A6000 |
Q4_K_M Default |
48 GB | 54 GB | e.g. multiple professional GPUs (2× A6000, H100) or DGX Spark |
Q5_K_M |
56 GB | 62 GB | e.g. multiple professional GPUs (2× A6000, H100) or DGX Spark |
Q6_K |
64 GB | 72 GB | e.g. multiple professional GPUs (2× A6000, H100) or DGX Spark |
Q8_0 |
83 GB | 92 GB | e.g. multiple professional GPUs (2× A6000, H100) or DGX Spark |
The Model Card lists one variant: Kolibri 1 (Aleph-Alpha/Kolibri-1) with FP8 weights (8-bit numbers), about 78 GB in size. The minimum requirement is 2× A100 80 GB, 2× H100 SXM5, 1× H200, 1× B200 or 1× B300. The recommended setup is 2× H100 SXM5, 2× H200, 1× B200 or 1× B300. The sources don't mention quantizations for smaller machines (e.g. 4-bit at roughly 45–50 GB). That's only an estimate, and it would have to come from the community. For everyday use on home hardware, that means: wait and see for now.
- Memory requirement per the Model Card: about 78 GB for the FP8 weights. On top of that you need room for the context (KV cache, the model's short-term memory).
- Minimum: 2× A100 80 GB, 2× H100 SXM5, 1× H200, 1× B200 or 1× B300. Recommended: 2× H100 SXM5, 2× H200, 1× B200 or 1× B300.
- Memory needs follow the full 78B parameters, not the 3.46B active ones. The active parameters only make computation faster.
- Long context costs memory. The Model Card recommends at most 262,144 tokens when speed or complex tasks matter. For more, there are dedicated vLLM options.
- Good news for long texts: most attention layers look only at nearby text. That keeps memory use lower at long context.
- The sources say nothing about running on CPU, Apple Silicon or with offloading (parts held in system RAM).
Groß (78,1 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
Google Colab (in your browser, no installation)
Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: Colab Pro only – needs an A100 with 40 GB.
- Download the notebook. Click the button and save the file.
- Open Colab. Go to colab.research.google.com and sign in with your Google account.
- Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file
colab.ipynb. - Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU (with Colab Pro: L4 or A100) → Save.
- Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
- Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 20 minutes here.
- Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
- Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.
Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.
Windows 10 / 11
The easiest way is Ollama, a free program that launches AI models with a single command.
- Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
- Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
- Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
- Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
The first time, Ollama downloads the model (48 GB (about 63 min at 100 Mbit/s)). After that, it's instant.ollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q4_K_M - Start typing. Once
>>> Send a messageappears, type your question and press Enter. Type/byeto end the chat.
Not enough memory? Pick a smaller variant from the table above, e.g. ollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q2_K.
Prefer automatic? A script that picks the right variant for you
- Download both files into the same folder: try_windows.ps1 demo.py
- Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.
- Paste this command and press Enter:
powershell -ExecutionPolicy Bypass -File try_windows.ps1
If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.
macOS
Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.
- Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
- Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
- Start the model. Paste the command (Cmd + V) and press Enter:
The first time, the model is downloaded (48 GB (about 63 min at 100 Mbit/s)).ollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q4_K_M - Start typing. Type your question and press Enter. Quit with
/bye.
Linux
- Check your GPU.
nvidia-smishould show your card. If it doesn't, install the driver on Ubuntu and restart:sudo ubuntu-drivers install - Install Ollama:
curl -fsSL https://ollama.com/install.sh | sh - Start the model:
Exit withollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q4_K_M/bye. Useollama psto check whether the model is running on the GPU. - Or let it pick the right variant automatically:
bash try_linux.sh # mit Python/transformers statt Ollama: MODE=hf bash try_linux.sh
Try it
Briefly explain what a mixture-of-experts model is.Write a formal email to the building authority asking for an extension on the deadline for my building permit application.Summarize this administrative notice in plain language in five sentences and list all deadlines: [insert text]Explain the difference between a maintenance interval and an inspection interval in aviation, and give an example.Extract the sender, date, amount and payment deadline from this invoice as JSON: [insert text]What's the weather like in Heidelberg right now? (with a weather tool set up, see tool calling)
Tips for better results
- Use the recommended sampling values (settings for how random the word choice is): temperature=1.0, top_p=0.97, top_k=128.
- For tricky tasks like math, logic or code, set reasoning_effort to low, medium or high. For quick answers, turn thinking off with enable_thinking=False or reasoning_effort=none.
- When thinking is on, raise max_new_tokens so there's still room for the answer after the reasoning. The thinking steps appear separately in message["thinking"].
- Be specific: task, audience, length and format (e.g. "five sentences," "as JSON"). Paste texts the model should rely on directly into the prompt.
- Don't make the context longer than necessary. Up to 262,144 tokens is the recommended range according to the Model Card.
If something goes wrong
Not enough memory: 78 GB of FP8 weights won't fit on a single consumer GPU. Plan for the minimum hardware from the Model Card or use a cloud server.
Transformers: the model is natively supported from version 5.20 (pip install "transformers[kernels,torch]>=5.20"). Older versions don't recognize the architecture.
vLLM: you need the aleph-alpha-inference package (>=1) with the Kolibri plugin, or the container image ghcr.io/aleph-alpha/aleph-alpha-inference. Standard vLLM isn't enough.
Launch parameters: for thinking mode and tools, start the server with --kv-cache-dtype fp8, --reasoning-parser kolibri1, --tool-call-parser kolibri1 and --enable-auto-tool-choice. Without them, thinking steps and tool calls don't come through cleanly.
Context beyond 262,144 tokens: add --max-model-len 1048576 and --hf-overrides '{"max_position_embeddings": 1048576}'. This costs memory and speed.
The sources don't mention quantizations or formats like GGUF for llama.cpp. Don't count on them existing yet.
The quality claims come from the vendor. Test with your own German examples and check important outputs (deadlines, numbers, legal matters) yourself.
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.