Aleph Alpha 开源德英双语模型 Kolibri：MoE 架构、Apache 2.0 与本地部署实测解析

2026年10月3日 / 阅读时间约10分钟 / 在𝕏上分享：https://x.com/intent/tweet?url=我刚刚阅读了由@TejasKumar_撰写的这篇有见地的博客文章，链接：https%3A%2F%2Ftej.as%2Fblog%2Faleph-alpha-kolibri

作者：Tejas Kumar / 关于，IBM 的人工智能工程师

Kolibri 是 Aleph Alpha 推出的开源大语言模型（LLM）：https://aleph-alpha.com/，支持德语和英语：一种专家混合模型，拥有 780 亿参数，但每处理一个 token 时仅使用其中约 35 亿个。它于 2026 年 10 月 3 日发布，采用 Apache 2.0 许可：https://www.apache.org/licenses/LICENSE-2.0，模型权重托管在 Hugging Face：https://huggingface.co/Aleph-Alpha/Kolibri-1，并且从零开始在德国和芬兰的基础设施上进行训练。（Kolibri 在德语中意为蜂鸟，这对于一个以轻量为特点的模型来说很可爱。）

衷心祝贺所有参与构建Kolibri的Aleph Alpha团队，我的好友Michael Hofmann（https://www.linkedin.com/in/michaellhofmann/）也在其中！

这篇文章介绍了Kolibri的工作原理、它的优势与劣势、如何运行以及何时是合适的选择。这里的所有内容都来自Aleph Alpha的189页技术报告：https://aleph-alpha.com/downloads/tech-report.pdf、模型卡：https://huggingface.co/Aleph-Alpha/Kolibri-1 以及他们的发布文章：https://aleph-alpha.com/en/blog/kolibri-has-landed-a-sovereign-open-weight-model/，再加上我对其分词器进行的一次实验。

Aleph Alpha称Kolibri为主权模型，在他们的发布文章中，这意味着两件事。第一是它的构建方式：“团队在德国构建了该模型，在德国和芬兰的基础设施上训练，遵循欧盟及德国法律，没有外国控制。”第二是客户获得的权利：“完全自由的部署和知识产权安全，因此合规性成为固有属性。”通俗地说，一个政府部门或汽车供应商可以在自己的服务器上运行它，数据永远不会离开大楼，并且没有人可以在其管理下更改或关闭模型。Aleph Alpha还签署了欧盟（https://european-union.europa.eu/）的通用人工智能（GPAI）行为准则：https://digital-strategy.ec.europa.eu/en/policies/contents-code-gpai.

Sovereign 并不意味着没有任何来自欧洲以外的内容被使用，模型卡本身也说明了这一点：英文网页文本经过 Google 的 Gemma 4（https://huggingface.co/google/gemma-4-26b-a4b-it）重新表述，德文文本使用 Mistral-NeMo（https://huggingface.co/mistralai/Mistral-Nemo-Instruct-2407），以及 Qwen3-32B（https://huggingface.co/Qwen/Qwen3-32B）标注的数据用于质量过滤。然后，他们对训练数据进行了政治偏见的过滤，这些模型可能存在的偏见，他们自己在中文开源模型中进行了测量（https://aleph-alpha.com/en/blog/training-on-the-party-line/）。

Kolibri 是将 6 个理念堆叠在一起，每一个都存在于为了让德语更便宜、更长或更诚实。

在一个普通的（密集）模型中，每个标记都会经过每一个参数。在专家混合（MoE）（https://huggingface.co/blog/moe）模型中，每一层都有一群称为专家的小型子网络和一个路由器，路由器为每个标记选取其中的几个。Kolibri 有 50 层，每层有 384 个专家，加上 1 个所有标记都经过的共享专家，其路由器将每个标记发送到 384 个专家中的 6 个。这样 781 亿参数就转化为每个标记实际工作量为 34.6 亿。

在 2024 年，我做了一场名为《为什么小型语言模型是未来》的演讲（https://www.youtube.com/watch?v=uNj3y2pItrA&t=72s），我主张“参数更少、出现问题的环节更少、需要计算量更小的小型语言模型。”我的比喻是，一个阅读了全世界所有医学书籍的医生与血液学专家相比：带血液问题去找前者，“他们可能不一定正确，因为他们知道太多。”专家混合模型则把满是专家的医院放进一个模型，而路由器就是接待员，将每个标记送到正确的 6 位专家那里。

不过这个类比在两个地方不适用。专家不像“德国法律”这样的整洁主题：当研究人员查看 MoE 模型时：https://huggingface.co/blog/moe#what-does-an-expert-learn，他们大多数发现专家是针对标记模式的，比如标点符号或专有名词，而不是人类会选择的主题。而且医院必须维持所有 384 名专家的在职状态，即使你只看 6 个，因此 Kolibri 的计算量相当于一个 35 亿参数的模型，但它需要 780 亿参数模型的内存。模型卡上明确写道：“完整的模型必须保存在内存中，尽管任何时候只有部分模型处于活动状态。”

模型不会读取字母或单词，它读取的是标记（token）：由固定词汇表中的文本块组成，在训练分词器时选择。德语将单词黏合成长的复合词，而一个主要从英语学习的分词器会将它们切分成小块。以下是联邦宪法法院的德语名称：https://www.bundesverfassungsgericht.de/EN/，由 GPT-4o 和 GPT-5 的分词器分割：https://en.wikipedia.org/wiki/GPT-5 使用（o200k_base，通过 OpenAI 的 tiktoken：https://github.com/openai/tiktoken），以及 Kolibri 的分词器分割方式：

Kolibri 的分词器有 128,000 个标记，使用 Aleph Alpha 称为 UniBPE 的新算法训练：它保留字节对编码（BPE）的自下而上合并：https://en.wikipedia.org/wiki/Byte-pair_encoding，并使用不同的评分规则（单元目标）选择每次合并，这种方法尊重德语的造词方式。报告中称，它处理德语文本所需的标记比 GPT-5 的分词器少 11.2%，在他们测量的另外 9 个分词器中是最好的。

我想亲自验证一下，所以我用 6 个分词器处理了《德意志联邦共和国基本法》全文：https://www.gesetze-im-internet.de/gg/，德国宪法（185 KB 的非常德式法律文本），以及其官方英文译本：https://www.gesetze-im-internet.de/englisch_gg/：

在德语法律文本上，Kolibri 所需标记比 GPT-5 的分词器少 15%，甚至超过 Aleph Alpha 自己报告的 11.2%，在英文文本中则与之持平。非常惊人。标记更少意味着阅读或写作相同德语文本的步骤更少，并且在同一上下文窗口中能容纳更多德语内容。（我用 Hugging Face 的 tokenizers 库用各自的 tokenizer.json 统计每个分词器的标记数量，除了 o200k_base 是用 tiktoken 统计的。）

科利布里（Kolibri）的50层中有40层使用滑动窗口注意力：每个标记只关注它前面的512个标记。每第5层会关注之前的所有内容。这就像是在阅读一份很长的合同时，主要注意当前的句子，而每隔几页就停下来回顾整篇合同，这也是让100万标记上下文保持可行的原因。

这里还有一个巧妙的细节。只有滑动窗口层知道标记的位置（通过旋转位置嵌入：https://arxiv.org/abs/2104.09864），而全注意层则不知道，因此上下文可以扩展到超过训练时的262,144个标记，而无需额外的位置技巧。Aleph Alpha 已验证可达1,048,576个标记。

在我的演讲《Unlocking Value with AI Today》中（https://www.youtube.com/watch?v=uMksIqpbVoY&t=364s），我把有限上下文称为生成式人工智能的“三大问题”之一，另外两个是幻觉和知识截止，科利布里同时解决这三大问题。在100万个标记的情况下，在RULER长上下文测试（https://arxiv.org/abs/2404.06654）中，科利布里的基础模型得分为63.2，而Qwen3.5 35B-A3B基础模型得分为57.5。

推理模型在回答前会先进行思考，即便是在德语提示下，它们大多也用英语思考。Aleph Alpha 在9月24日发布了相关内容（https://x.com/Aleph__Alpha/status/2103139585039511700），并在《Through the Valley of Tears》中做了详细说明（https://aleph-alpha.com/en/blog/through-the-valley-of-tears-cold-starting-german-reasoning-in-llms/）：他们生成了大约800,000个德语推理示例，发现少量德语推理数据比没有更糟。他们模型的德语数学得分从70.2降到48.3，因为它的德语思维一直循环未完成，只有在大量德语数据下才回升到67.3。

科利布里拥有更多的数据。它能在德语提示下进行德语推理，其德语数学成绩在约30亿活跃参数的模型中名列前茅：2025年美国邀请数学考试（AIME，https://en.wikipedia.org/wiki/American_Invitational_Mathematics_Examination) 德语成绩为87.5，而次佳成绩是NVIDIA的Nemotron 3 Nano（https://developer.nvidia.com/nemotron），得分为84.4。

幻觉是我三大主要问题中的第一位，而在那次演讲中提出的解决方法是检索增强生成（RAG）：你查找可靠的权威信息并将其放入提示中。然而，RAG 只有在模型承认文档中没有答案时才有效，而这正是 Aleph Alpha 训练的目标，他们使用自己的方法，即 Merlin-Arthur 协议：https://arxiv.org/abs/2512.11614。

它的运作方式像一个三人游戏。Arthur 是模型，他会获得一个问题，其中部分支持文档被隐藏。Merlin 会隐藏部分内容，使正确答案更容易找到，而 Arthur 被训练去回答这些问题。Morgana 会隐藏答案所依赖的证据，而 Arthur 被训练去说“我不知道”。Arthur 永远不知道自己面对的是哪一个，所以赢的方法只有一个，那就是实际检查面前的证据是否支持一个答案。

结果显而易见。在 Artificial Analysis 的 Omniscience 测试中：https://artificialanalysis.ai/evaluations/omniscience，当 Kolibri 不知道答案时，它有 44% 的情况下会直接说明（或给出部分答案），而不是编造答案。Qwen3.5 35B-A3B 这么做的比例为 11.1%，GPT-OSS 120B 为 23.7%。在 Aleph Alpha 比较的所有混合专家模型中，只有 Qwen3.6 35B-A3B：https://huggingface.co/Qwen/Qwen3.6-35B-A3B 更好，比例为 56.7%。

每个请求都可以将 reasoning_effort 设置为 none、low、medium 或 high，因此一个简单的查询可以马上得到答案，而一个难题则会经过长时间思考，这都是同一台服务器上的同一个模型处理的。

以下是 Kolibri 在 Aleph Alpha 评测中超越同规模开放模型的项目。评测对每个模型都使用相同的设置，并采用其开发者推荐的采样参数进行测试：

数学表现尤其突出：在 2025 和 2026 年的 AIME 英语考试中，它击败了比较中的所有 MoE 模型，包括那些有 120 亿有效参数的模型，只有密集的 Qwen3.8 27B 得分更高。公司文件栏显示的是由 Aleph Alpha 根据客户类似的工作构建的 5 个测试，涵盖半导体、德国公共部门、航空航天、汽车供应商和工业传动，测试文档和问题模型在训练中从未见过。

Aleph Alpha 在模型卡中将最弱的表现和最强的表现并列展示，所以这里是它们的情况：

你需要大约 78 GB 的 GPU 内存：2 块 NVIDIA A100 或 H100：https://www.nvidia.com/en-us/data-center/h100/，每块至少 80 GB，或者一块 H200：https://www.nvidia.com/en-us/data-center/h200/、B200 或 B300。我本人还没有运行过模型本身，因为它需要数据中心级 GPU，并且目前没有人托管它，所以这些信息直接来自模型卡。首先是插件，它安装支持的 vLLM 版本：https://docs.vllm.ai/：

这会给你一个兼容 OpenAI 的服务器，所以任何 OpenAI 客户端都可以与其对接，推理过程通过聊天模板进行：

模型卡建议 temperature=1.0、top_p=0.97 和 top_k=128，对于任何对延迟敏感的任务，最大上下文为 262,144 个 token。对于完整的一百万 token，可以加上两个额外的参数：

当德文文本和你自己的硬件都很重要时，Kolibri 是首选：一个公共机构、银行、制造商或航空航天供应商必须将文件保存在内部，希望获得用德语思考的德语答案，并且宁愿听到“我不知道”也不想要自信但错误的回答。在长篇德文文件（法律、合同、手册）上进行 RAG 正好发挥了上面提到的所有优势：分词器、一百万 token 上下文和回避选项。

这就是我目前正在进行的项目，合作对象是 Heinrich Audebert 教授：https://schlaganfallcentrum.charite.de/en/research/research_groups/audebert，他负责 Campus Benjamin Franklin 的神经科：https://neurologie.charite.de/en/，这是柏林 Charité：https://www.charite.de/en/ 的一家医院。今天，有神经系统问题的患者会去看他们的全科医生（GP），而 GP 必须亲自看诊，这对繁忙的诊所来说非常费力。在我们正在建设的系统中，患者坐在 GP 诊所的电脑前，一个 AI 虚拟形象会引导他们完成一系列测试，并评估他们症状的紧急程度：立即转诊给专家，或者可以等待一会儿。对话都是用德语进行的，内容涉及人们的健康，并且模型必须在我们可控的环境中运行，所以我们考虑使用 Kolibri 来实现它。

对于编码代理来说，这是错误的选择，Qwen3.6 35B-A3B 更适合处理模型需要凭记忆回答的问题，适用于除了德语和英语之外的任何语言，以及对于任何无法提供 78 GB GPU 内存的人来说。对于最后一种情况，我在 2024 年主张的小型专用模型仍然是答案：为了我的播客搜索，我在 Apple Silicon 笔记本上微调了 Mistral 7B：https://www.youtube.com/watch?v=uNj3y2pItrA&t=231s，而不是支付 GPT-4o 的费用。

哪种模型更适合你自己的文档，是像 Kolibri 这样由专家组成的团队，还是针对单一任务训练的小型模型，只有在你尝试在你的数据上运行两者时才会显示结果。在代理下更换模型而不破坏其功能，是我在可靠 AI 代理研讨会中讲授的内容之一：无论底层模型是什么，都能生效的防护措施和重试机制。

我在舞台上展示这些材料，是为你的观众量身定制，而不是简单回放。告诉我活动信息，我会告诉你如果有这个演讲时间我会怎么做。

Kolibri 是 Aleph Alpha 发布的开源权重大型语言模型，适用于德语和英语，于 2026 年 10 月 3 日在 Apache 2.0 许可证下发布。它是一个混合专家模型，拥有 780 亿参数，其中大约 35 亿参数作用于每个 token，能够读取多达 100 万个 token 的上下文，并且从零开始在德国和芬兰的基础设施上进行训练。

主权 AI 模型是指一个组织可以完全在其控制的基础设施上运行，并且遵循其必须遵守的法律构建的模型，这样其数据仍然掌握在自己手中，其他人无法更改或关闭模型。Aleph Alpha 对 Kolibri 使用了两个“主权”的含义：模型如何构建（由德国团队在德国和芬兰的基础设施上、根据欧洲和德国法律构建）以及它如何到达客户（开放权重，客户可以在任何地方运行）。

Kolibri 的权重在 Hugging Face 上开放，使用 Apache 2.0 许可证，因此任何人都可以下载、运行、微调并基于它们构建产品。许可证涵盖权重和配置文件，Aleph Alpha 保留其训练代码和方法的权利。

Kolibri 权重大约需要 78 GB 的 GPU 内存，因此至少需要两块每块 80 GB 的 NVIDIA A100 或 H100 GPU，或者一块 H200、B200 或 B300。每个 token 只有大约 35 亿参数在工作，但所有 780 亿参数都必须驻留在内存中。

在每个令牌使用数十亿参数的开放混合专家模型中，Kolibri 在 Aleph Alpha 自身的评估中获得了最高的德语分数：70.8，而 Qwen3.5 35B-A3B 的得分为 69.8，该模型具有 350 亿参数，每个令牌有 30 亿激活参数（A3B）。密集型 Qwen3.8 27B 得分更高，为 79.9，但它每个令牌使用的参数几乎是前者的 8 倍。

本文由我，Tejas Kumar 撰写，我是 IBM 的 AI 工程师，常驻柏林。阅读我写的其他内容：/blog，或查看《Fluent React》，我的 O'Reilly 书籍，讲解 React 内部工作原理：/react，我在会议上发表的演讲：/speaking，和我的播客 ConTejas Code：/podcast。

研讨会：/workshops 演讲：/speaking 精通 React：/react 关于：/about 我的故事：/story 投资：/investing 我的近况：/status：https://x.com/TejasKumar_LinkedIn：https://www.linkedin.com/in/tejasq YouTube：https://www.youtube.com/@tejask GitHub：https://github.com/TejasQ

Taz Singh 的肖像：https://ca.linkedin.com/in/taz-singh-468b59109

Oct 3, 2026 / 10 min read / Share on 𝕏：https://x.com/intent/tweet?url=I%20just%20read%20this%20insightful%20blog%20post%20by%20%40TejasKumar_%20at%20https%3A%2F%2Ftej.as%2Fblog%2Faleph-alpha-kolibri

By Tejas Kumar：/about, AI Engineer at IBM

Kolibri is an open-weight large language model (LLM) from Aleph Alpha：https://aleph-alpha.com/ for German and English: a mixture of experts with 78 billion parameters that only uses about 3.5 billion of them for each token it reads or writes. It came out on 3 October 2026 under the Apache 2.0 license：https://www.apache.org/licenses/LICENSE-2.0, the weights are on Hugging Face：https://huggingface.co/Aleph-Alpha/Kolibri-1, and it was trained from scratch on infrastructure in Germany and Finland. (Kolibri is German for hummingbird, which is cute for a model whose whole trick is being light.)

Huge congrats to everyone at Aleph Alpha who built it, my good friend Michael Hofmann：https://www.linkedin.com/in/michaellhofmann/ among them!

This post is about how Kolibri works, where it’s strong, where it isn’t, how to run it, and when it’s the right pick. Everything here comes from Aleph Alpha’s 189 page technical report：https://aleph-alpha.com/downloads/tech-report.pdf, the model card：https://huggingface.co/Aleph-Alpha/Kolibri-1 and their launch post：https://aleph-alpha.com/en/blog/kolibri-has-landed-a-sovereign-open-weight-model/, plus one experiment I ran on its tokenizer.

Aleph Alpha calls Kolibri sovereign, and in their launch post that means 2 things. The first is how it was built: “teams built the model in Germany, trained it on infrastructure in Germany and Finland, under European and German law, with no foreign control.” The second is what customers get: “full freedom of deployment and intellectual-property safety, so compliance comes as an inherited property.” In plain words, a ministry or a car supplier can run it on its own servers, with its data never leaving the building, and nobody can change or switch off the model under them. Aleph Alpha has also signed the European Union：https://european-union.europa.eu/’s General-Purpose AI (GPAI) Code of Practice：https://digital-strategy.ec.europa.eu/en/policies/contents-code-gpai.

Sovereign doesn’t mean that nothing from outside Europe went in, and the model card says so itself: English web text was rephrased with Google’s Gemma 4：https://huggingface.co/google/gemma-4-26b-a4b-it, German with Mistral-NeMo：https://huggingface.co/mistralai/Mistral-Nemo-Instruct-2407, and Qwen3-32B：https://huggingface.co/Qwen/Qwen3-32B labeled data for the quality filters. They then filtered the training data for the political bias such models can have, which they’ve measured in Chinese open models：https://aleph-alpha.com/en/blog/training-on-the-party-line/ themselves.

Kolibri is 6 ideas stacked on top of each other, and each one is there to make German cheaper, longer or more honest.

In a normal (dense) model, every token goes through every parameter. In a mixture of experts (MoE)：https://huggingface.co/blog/moe, each layer has a crowd of small sub-networks called experts and a router that picks a few of them for each token. Kolibri has 50 layers, each with 384 experts plus 1 shared expert that every token goes through, and its router sends each token to 6 of the 384. That’s how 78.1 billion parameters turn into 3.46 billion of actual work per token.

In 2024 I gave a talk called Why Small Language Models are the future：https://www.youtube.com/watch?v=uNj3y2pItrA&t=72s, and I argued for “smaller language models with fewer parameters and fewer places things can go wrong that require lesser compute.” My analogy was a doctor who has read every medical book in the world against a specialist in hematology: go to the first one with a blood condition and “they may not get it right cuz they know too much.” A mixture of experts puts a hospital full of specialists inside one model, and the router is the receptionist who sends each token to the right 6.

The analogy breaks in 2 places though. The experts aren’t neat topics like “German law”: when researchers look inside MoE models：https://huggingface.co/blog/moe#what-does-an-expert-learn they mostly find experts for patterns of tokens, like punctuation or proper nouns, not subjects a person would pick. And the hospital has to keep all 384 specialists on staff even if you only see 6, so Kolibri computes like a 3.5 billion parameter model but needs the memory of a 78 billion parameter one. The model card says it plainly: “the full model must be held in memory even though only part of it is active at any time.”

A model doesn’t read letters or words, it reads tokens: chunks of text from a fixed vocabulary, picked when the tokenizer is trained. German glues words together into long compound words, and a tokenizer that learned mostly from English chops them into pieces. Here’s the German name of the Federal Constitutional Court：https://www.bundesverfassungsgericht.de/EN/, split by the tokenizer GPT-4o and GPT-5：https://en.wikipedia.org/wiki/GPT-5 use ( o200k_base , through OpenAI’s tiktoken：https://github.com/openai/tiktoken), and by Kolibri’s:

Kolibri’s tokenizer has 128,000 tokens, trained with a new algorithm Aleph Alpha calls UniBPE: it keeps the bottom-up merging of byte-pair encoding (BPE)：https://en.wikipedia.org/wiki/Byte-pair_encoding and picks each merge with a different scoring rule (the Unigram objective), which respects how German builds words. The report says it needs 11.2% fewer tokens for German text than GPT-5’s tokenizer, the best of the 9 others they measured.

I wanted to see that for myself, so I ran 6 tokenizers over all of the Basic Law for the Federal Republic of Germany：https://www.gesetze-im-internet.de/gg/, the German constitution (185 KB of very German legal text), and over its official English translation：https://www.gesetze-im-internet.de/englisch_gg/:

On legal German, Kolibri needed 15% fewer tokens than GPT-5’s tokenizer, even more than Aleph Alpha’s own 11.2%, and in English it tied with it. Wild. Fewer tokens means fewer steps to read or write the same German text, and more German fits in the same context window. (I counted each one with its own tokenizer.json through Hugging Face’s tokenizers library, except o200k_base , which I counted with tiktoken.)

40 of Kolibri’s 50 layers use sliding-window attention: each token only looks at the 512 tokens before it. Every 5th layer looks at everything before it. It’s like reading a long contract while mostly paying attention to the sentence you’re on, and every few pages stopping to think about all of it, and it’s what keeps a 1 million token context affordable.

There’s a clever detail in there too. Only the sliding-window layers know where a token sits (through rotary position embeddings：https://arxiv.org/abs/2104.09864), and the full-attention layers don’t, so the context stretches past the 262,144 tokens it was trained on without any extra position tricks. Aleph Alpha validated it up to 1,048,576.

In my talk Unlocking Value with AI Today：https://www.youtube.com/watch?v=uMksIqpbVoY&t=364s I called finite context one of “the big three” problems of generative AI, next to hallucination and the knowledge cutoff, and Kolibri goes after all 3. At 1 million tokens, on the RULER：https://arxiv.org/abs/2404.06654 long-context test, Kolibri’s base model scores 63.2, against 57.5 for Qwen3.5 35B-A3B’s base model.

Reasoning models think before they answer, and even on German prompts they mostly think in English. Aleph Alpha posted about this：https://x.com/Aleph__Alpha/status/2103139585039511700 on 24 September and wrote it up as Through the Valley of Tears：https://aleph-alpha.com/en/blog/through-the-valley-of-tears-cold-starting-german-reasoning-in-llms/: they generated about 800,000 German reasoning examples, and found that a little German reasoning data is worse than none. Their model’s German math score dropped from 70.2 to 48.3, because its German thoughts kept going around in circles and never finished, and it only climbed back (to 67.3) with a lot more German data.

Kolibri got the lot more. It reasons in German on German prompts, and its German math scores are the best of the models with about 3 billion active parameters: 87.5 on the American Invitational Mathematics Examination (AIME)：https://en.wikipedia.org/wiki/American_Invitational_Mathematics_Examination 2025 in German, against 84.4 for the next best, NVIDIA’s Nemotron 3 Nano：https://developer.nvidia.com/nemotron.

Hallucination was number 1 of my big three, and the fix in that talk was retrieval augmented generation (RAG): you look up good, authoritative information and put it in the prompt. RAG only works if the model admits when the documents don’t have the answer, though, and that’s what Aleph Alpha trained for, with their own method, the Merlin-Arthur protocol：https://arxiv.org/abs/2512.11614.

It works like a game with 3 players. Arthur is the model, and he gets a question with parts of the supporting document hidden. Merlin hides parts so that the correct answer gets easier to find, and Arthur is trained to answer those. Morgana hides the evidence the answer depends on, and Arthur is trained to say he doesn’t know. Arthur never knows which of the 2 he’s facing, so the only way to win is to actually check whether the evidence in front of him supports an answer.

It shows. On Artificial Analysis’s Omniscience test：https://artificialanalysis.ai/evaluations/omniscience, when Kolibri didn’t know an answer, it said so (or gave a partial answer) 44% of the time instead of making one up. Qwen3.5 35B-A3B did that 11.1% of the time and GPT-OSS 120B 23.7%. Of all the mixture-of-experts models Aleph Alpha compared, only Qwen3.6 35B-A3B：https://huggingface.co/Qwen/Qwen3.6-35B-A3B did better, at 56.7%.

Every request can set reasoning_effort to none , low , medium or high , so a quick lookup answers right away and a hard question gets a long think, from the same model on the same server.

These are the rows where Kolibri leads the open models of its size in Aleph Alpha’s evaluation, which runs every model through the same setup with the sampling settings its makers recommend:

The math is the standout: on AIME 2025 and 2026 in English it beats every MoE model in the comparison, including the ones with 12 billion active parameters, and only the dense Qwen3.8 27B scores higher. The company-documents row is 5 tests Aleph Alpha built from customer-like work in semiconductors, the German public sector, aerospace, an automotive supplier and industrial drives, run over documents and questions the model never saw in training.

Aleph Alpha publishes its weakest rows right next to its best ones in the model card, so here they are:

You need about 78 GB of GPU memory: 2 NVIDIA A100s or H100s：https://www.nvidia.com/en-us/data-center/h100/ with 80 GB each at the least, or a single H200：https://www.nvidia.com/en-us/data-center/h200/, B200 or B300. I haven’t run the model itself yet, since it needs a data-center GPU and nobody hosts it so far, so this is straight from the model card. First the plugin, which installs the vLLM：https://docs.vllm.ai/ version it supports:

That gives you an OpenAI-compatible server, so any OpenAI client talks to it, and the reasoning effort goes through the chat template:

The model card recommends temperature=1.0 , top_p=0.97 and top_k=128 , and contexts of at most 262,144 tokens for anything latency-sensitive. For the full million, serve it with 2 more flags:

Kolibri is the pick when German text and your own hardware both matter: a public authority, a bank, a manufacturer or an aerospace supplier that has to keep its documents in house, wants answers in German that reason in German, and would rather hear “I don’t know” than a confident wrong answer. RAG over long German documents (laws, contracts, manuals) plays to every strength above: the tokenizer, the 1 million token context and the abstention.

That’s the kind of project I’m working on right now, with Prof. Dr. Heinrich Audebert：https://schlaganfallcentrum.charite.de/en/research/research_groups/audebert, who heads neurology at Campus Benjamin Franklin：https://neurologie.charite.de/en/, one of the Charité：https://www.charite.de/en/’s hospitals in Berlin. Today, a patient with a neurological complaint goes to their general practitioner (GP), and the GP has to see them, which is very demanding for a busy practice. In what we’re building, the patient sits down at a computer in the GP’s practice, an AI avatar takes them through a battery of tests, and it grades how urgent their symptoms are: a referral to a specialist right away, or they can wait a bit. The conversations are in German, they’re about people’s health, and the model has to run where we control it, so we’re thinking of using Kolibri for it.

It’s the wrong pick for a coding agent, where Qwen3.6 35B-A3B leads, for questions the model has to answer from memory, for any language besides German and English, and for anyone who can’t spare 78 GB of GPU memory. For that last case, the small specialized model I argued for in 2024 is still the answer: for my podcast search I fine-tuned Mistral 7B on my Apple silicon laptop：https://www.youtube.com/watch?v=uNj3y2pItrA&t=231s instead of paying for GPT-4o.

Which is better for your own documents, a hospital of specialists like Kolibri or one small model trained for a single job, only shows when you try both on your data. Swapping the model under an agent without breaking it is what my workshop on reliable AI agents：/workshops#ai-agents covers: guardrails and retries that work whichever model sits underneath.

I give this material on stage, built for your audience rather than replayed. Tell me about the event and I will tell you what I would do with the slot.

Kolibri is an open-weight large language model from Aleph Alpha for German and English, released on 3 October 2026 under the Apache 2.0 license. It's a mixture of experts with 78 billion parameters, of which about 3.5 billion work on each token, it reads up to 1 million tokens of context, and it was trained from scratch on infrastructure in Germany and Finland.

A sovereign AI model is one an organization can run entirely on infrastructure it controls, built under the laws it has to follow, so its data stays in its hands and nobody else can change or switch off the model. Aleph Alpha uses the word in 2 senses for Kolibri: how the model was built (by teams in Germany, on infrastructure in Germany and Finland, under European and German law) and how it reaches customers (open weights they can run anywhere).

Kolibri's weights are open under the Apache 2.0 license on Hugging Face, so anyone can download them, run them, fine-tune them and build products on them. The license covers the weights and configuration files, and Aleph Alpha keeps the rights to its training code and methods.

Kolibri needs about 78 GB of GPU memory for its weights, so the minimum is 2 NVIDIA A100 or H100 GPUs with 80 GB each, or 1 H200, B200 or B300. Only about 3.5 billion parameters work on each token, but all 78 billion have to sit in memory.

Among open mixture-of-experts models that use a few billion parameters per token, Kolibri has the highest German score in Aleph Alpha's own evaluation: 70.8, against 69.8 for Qwen3.5 35B-A3B, which has 35 billion parameters with 3 billion active (A3B) per token. The dense Qwen3.8 27B scores higher at 79.9, but it uses nearly 8 times as many parameters for every token.

Written by me, Tejas Kumar, an AI Engineer at IBM based in Berlin. Read everything else I have written：/blog, or go to Fluent React, my O'Reilly book on how React works inside：/react, the talks I give at conferences：/speaking, and ConTejas Code, my podcast：/podcast.

Workshops：/workshopsSpeaking：/speakingFluent React：/reactAbout：/aboutMy story：/storyInvesting：/investingHow I'm doing：/status ：https://x.com/TejasKumar_LinkedIn：https://www.linkedin.com/in/tejasqYouTube：https://www.youtube.com/@tejaskGitHub：https://github.com/TejasQ

Portrait by Taz Singh：https://ca.linkedin.com/in/taz-singh-468b59109