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.

Model releases Try it yourself Oct 26, 2026 4 min read Source: arXiv cs.CL
Illustrative image, AI-generated

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

#kolibri#aleph-alpha#moe#german#open-weights
Read the original source

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

Make official letters easy to understand

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.

Draft formal letters and emails

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.

Ask questions about your own documents (RAG)

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.

Work through long reports

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.

Write and explain code

You have it write small scripts, interpret error messages or comment code. For tricky cases, turn on reasoning. Always test the code yourself.

Build an assistant with tools

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.

Size78.1 B parameters (3.46 billion active)
Download48 GB (about 63 min at 100 Mbit/s)
Licenseapache-2.0
TypeLanguage model (text chat)

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 32 GB VRAM, recommended 54 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark – fastest; with less VRAM, see the next line
Graphics card + system memory (MoE offloading) from approx. 6 GB VRAM + 64 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar
Mac (Apple Silicon M1–M5) from 96 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
CPU only (no graphics card) Runs smoothly without a graphics cardan estimated 11 words per second on a current desktop PC (MoE: only 3.46 billion parameters active per word). This requires at least 64 GB of RAM.
Storage approx. 50 GB freeModel download plus programs
Google Colab Colab Pro onlyneeds an A100 with 40 GB

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.

VariantDownloadNeeds approx.Compatible graphics cards
Q2_K 29 GB32 GBe.g. 2× RTX 3090/4090 or RTX A6000
Q3_K_M 38 GB42 GBe.g. 2× RTX 3090/4090 or RTX A6000
Q4_K_M Default 48 GB54 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark
Q5_K_M 56 GB62 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark
Q6_K 64 GB72 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark
Q8_0 83 GB92 GBe.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-smi in the terminal (shows your graphics card and its memory) and free -h for 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.

  1. Download the notebook. Click the button and save the file.

    Download colab.ipynb

  2. Open Colab. Go to colab.research.google.com and sign in with your Google account.
  3. 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.
  4. 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.
  5. Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
  6. 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.
  7. 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.
  8. 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.

  1. Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
  2. 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.
  3. Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
  4. Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
    ollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q4_K_M
    The first time, Ollama downloads the model (48 GB (about 63 min at 100 Mbit/s)). After that, it's instant.
  5. Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to 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
  1. Download both files into the same folder: try_windows.ps1 demo.py
  2. Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.
  3. 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.

  1. 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.
  2. Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
  3. Start the model. Paste the command (Cmd + V) and press Enter:
    ollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q4_K_M
    The first time, the model is downloaded (48 GB (about 63 min at 100 Mbit/s)).
  4. Start typing. Type your question and press Enter. Quit with /bye.
Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

  1. Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
    sudo ubuntu-drivers install
  2. Install Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
  3. Start the model:
    ollama run hf.co/Hob-forge/Kolibri-1-GGUF:Q4_K_M
    Exit with /bye. Use ollama ps to check whether the model is running on the GPU.
  4. Or let it pick the right variant automatically:

    try_linux.sh

    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.

Connecting …

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.

  1. Loading comments …

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.