Kolibri: What Aleph Alpha's 78B Open-Weight Model Actually Is

Kolibri is an open-weight language model from Aleph Alpha, the Heidelberg lab that has spent years arguing that European institutions need models they can run on their own hardware. It is a 78-billion-parameter mixture-of-experts system that activates about 3.46 billion parameters per token, reads and writes German and English and nothing else, and carries a validated context window of 1,048,576 tokens. The weights sit on Hugging Face in a repository called Aleph-Alpha/Kolibri-1, under Apache 2.0. The same release materials also describe Kolibri Origin, a 30.6-billion-parameter predecessor that was trained, validated internally and never released. If you searched the bare name and landed here, that is the short answer; the rest of this page is the specification behind it, each figure attributed to the source that publishes it.

The model shipped on 3 October 2026 — Aleph Alpha's own news post, dated Heidelberg, 5 October, states that Kolibri has been available since 3 October, and the model card carries the same date. That date is here to place the model, not to announce it. What follows is the standing version: what the model is, what it is not, which numbers come from Aleph Alpha and which, as of today, come from nobody at all.

Kolibri, Kolibri-1, Kolibri Origin: three names, one release

The naming is the first thing a reader has to get straight, because the vendor uses two of these interchangeably and a third belongs to something else entirely.

• Kolibri — the model's name in everything Aleph Alpha writes: the product page, the announcement, the technical report. A German word, and the vendor spells it exactly that way, capital K, no suffix.

• Kolibri-1 — the same model at the repository level. The Hugging Face repo is Aleph-Alpha/Kolibri-1, and the serving command the vendor publishes is vllm serve Aleph-Alpha/Kolibri-1. This is a version identifier, not a second model, and the two strings resolve to identical weights.

• Kolibri Origin — a different model, and not one you can download. It is the 30.6-billion-parameter, 3.27-billion-active predecessor that finished pre-training in June 2026, was used to validate the training pipeline, and was never published. Aleph Alpha reports most of Kolibri's benchmark rows as a paired column against it, which is why the name turns up in nearly every table about Kolibri. If you are looking for weights, this is not the one to search for.

There is no separate "Kolibri 2", no chat-tuned variant published under a different name, and no quantised official distribution. Anything else wearing the name in a download index is a third-party conversion, and the vendor's own material does not document one.

Size: the 78B figure is right, and it is the second number that decides everything

A "Kolibri 78B" query has been circulating, and the vendor confirms it rather than correcting it. From the model card, published with the weights: 78,103,074,560 total parameters, of which 3,457,573,120 are active per token. That is a sparsity ratio of roughly 22.6 to 1.

The distinction is not pedantry. Total parameters determine how much memory the model needs; active parameters determine how much compute each token costs. A 78B model with 3.46B active is a very large artefact that behaves, at inference time, like a small one on a per-token basis — and that is exactly why Aleph Alpha can quote a two-GPU deployment floor for something this size. Any summary of Kolibri that gives you 78B without the active figure has left out the part that governs the bill.

For scale against its own lineage: Kolibri Origin was 30.6B total with 3.27B active. Kolibri roughly doubles the total parameter count while barely moving the active count, which is a statement about capacity per unit of serving cost rather than about raw speed.

Architecture and licence: what the weights are, and what Apache 2.0 actually covers here

Kolibri is a 50-layer mixture-of-experts transformer with no dense feed-forward layers at all. Each layer routes to 384 experts, six of them active per token, plus one shared expert; the expert intermediate dimension is 512 and the model dimension is 2,560. Attention is hybrid: most layers use a sliding window of 512 tokens, with full attention only every fifth layer. Aleph Alpha's architecture write-up puts the consequence plainly — the fraction of pure attention work drops from 51 per cent to 27 per cent at a 16K context compared with Kolibri Origin, and the full-attention layer count falls by roughly a factor of five.

The tokenizer is a bilingual German-English build with a 128,000-token vocabulary, trained with a method the lab calls UniBPE. Two languages, deliberately: the vendor frames the scope as depth over breadth and says so in as many words, rather than presenting two well-served languages as a multilingual achievement.

Licence is Apache 2.0, and the model card is unusually precise about its boundary. The licence applies, in the card's own wording, "only to the weights and configuration files published in this repository" — it does not extend to the underlying code, the architecture definition, the parameter settings or the training method. So the practical position for a deployment team is this: the weights are genuinely open and commercially usable with no acceptable-use rider, no monthly-active-user threshold and no separate commercial terms, but the licence is not a grant over Aleph Alpha's training recipe or its inference code. If your legal review asks whether this is open source in the OSI sense, the honest answer is that it is open weights under an OSI-approved licence with a stated scope limit, and those are not the same claim.

Context window and maximum output

Aleph Alpha publishes the context window in two tiers, and the distinction is worth keeping.

• Validated maximum — 1,048,576 tokens, stated on both the product page and the model card.

• Native and recommended — 262,144 tokens. The card recommends staying at or below this for serving efficiency and for complex tasks; the vendor page calls 256K the working figure.

• Training progression — pre-trained at 16,384 tokens, mid-trained at a 65,536-token horizon, then extended to 262,144 as the trained length.

Reaching the full million is not a configuration you get by default. The serving recipe requires an explicit maximum-model-length flag and a position-embedding override, which the vendor documents. Read 1M as a validated ceiling with a documented procedure, and 262K as the number to design a production workload around.

Maximum output length is not published. Neither the product page, the model card nor the announcement states a generation cap. If a deployment depends on a hard output limit, that is a question for Aleph Alpha or for your own serving configuration — not something the release material answers.

Modalities: text only, and that is a deliberate boundary

Kolibri is a text-in, text-out model. The card's pipeline tag is text generation, it describes the model as processing text input and producing text output, and it notes that the training corpus is text-only. No vision encoder, no audio path, no image generation, no documented tool-result modality beyond text-shaped tool calls.

This is the point where vendor language and reader expectation most often diverge, so it is worth saying flatly: nothing about Kolibri's name, its size or its sibling models should lead you to assume it accepts images. It does not. Its two languages are German and English, and it is not built to handle a third — a request in French or Spanish is outside the design target regardless of what a demo does with it.

What it does have is tool calling — Hermes-style, with a parser shipped in the same repository as the weights — and four reasoning effort levels, none, low, medium and high, set through the chat template. Both are documented behaviours, not community findings.

What Aleph Alpha claims, and what anyone else has measured

Two categories, and they are not the same size.

Vendor-reported, from Aleph Alpha's own harness, run by Aleph Alpha, published by Aleph Alpha: Kolibri sits on the Pareto frontier of quality against serving cost for English and German; it matches models with up to four times its active parameter count, a claim the vendor illustrates with Nemotron 3 Super, a 120B-A12B model; it is specialised for German, reasoning, mathematics and agentic work, with strong tool-use rows (Tau2-Bench telecom 94.7 per cent, retail 69.9 per cent, airline 76.7 per cent; BFCL v4 overall 61.4 per cent) and reasoning rows (GPQA Diamond 84.3 per cent English, AIME 2025 96.9 per cent English). The German figures in that same table — GPQA Diamond 81.3 per cent, AIME 2025 87.5 per cent, AIME 2026 90 per cent — come from a German-language rendering of the same benchmarks.

Independently measured, as of 13 October 2026: nothing. There is no Artificial Analysis entry for Kolibri and no Aleph Alpha row on its provider list; the model card itself states that the model is not deployed by any inference provider on Hugging Face; and no third party has published a reproduction of the vendor's evaluation framework, even though the harness code is public in the lab's own repository. The evaluation is thorough and it is one lab's evaluation. Treat every percentage above as a vendor claim until someone outside Heidelberg runs it.

One number in the vendor's material deserves particular care rather than repetition. Aleph Alpha's product page shows an AA-Omniscience index of 33.6 per cent for Kolibri. That index is an Artificial Analysis construct, and Artificial Analysis currently publishes no Kolibri entry. The figure is Aleph Alpha's own run of someone else's index, which is a legitimate thing to publish and an illegitimate thing to read as an independent score. It is a vendor-reported number until the index owner prints one.

How you actually run it

There is no hosted endpoint to point at. Kolibri is distributed as weights plus an inference package, and calling it means running it yourself.

• Install — pip install "aleph-alpha-inference>=1.0", which provides the Kolibri vLLM plugin and pins the vLLM version it supports; alternatively pull the container image ghcr.io/aleph-alpha/aleph-alpha-inference.

• Serve — a standard vLLM invocation against Aleph-Alpha/Kolibri-1, with an FP8 KV cache, the Kolibri reasoning parser, the Kolibri tool-call parser and automatic tool choice enabled.

• Memory — the FP8 weights are about 78 GB. Published minimum is two A100 80 GB cards, two H100 SXM5s, one H200, one B200 or one B300; the recommended configuration is two H100 SXM5s, two H200s, one B200 or one B300.

• Sampling — temperature 1.0, top-p 0.97, top-k 128, per the card's recommendation.

• Interface — OpenAI-compatible, served locally. Existing chat-completions code can point at it; reasoning effort travels through the chat template and tool calls land in the standard tools field.

The vendor's own sign-up form offers "Modelltest API" as a request category, so an API conversation is possible through sales. Nothing published describes it as available, priced or self-serve.

Nothing in the release material states a price, because there is nothing to price: the weights are free to download and the cost of using Kolibri is the cost of the GPUs you put under it. Aleph Alpha also publishes no rate limits, no free credits and no trial tier for the model — any claim to the contrary would be an inference from the word "available", not a fact from the vendor's pages.

No route on OrcaRouter, and the honest alternative

We checked our own catalogue today: OrcaRouter serves 207 models and Kolibri is not among them, under any spelling of the name or the Aleph Alpha prefix. That matters for a reader whose actual question is "can I call this without buying two H100s", because the answer is no — not here, and not on the vendor's own infrastructure as a published service. Self-hosting is the only way to run Kolibri right now.

If what you need is a German-and-English-capable mixture-of-experts model you can call this afternoon, the nearest thing we do carry is Gemma 4 26B A4B IT, an open-weight MoE at $0.06 per million input tokens and $0.33 per million output tokens with a 262,144-token window — the same context class as Kolibri's recommended working figure, at a per-token line item instead of 78 GB of VRAM and a procurement conversation. OrcaRouter routes every model it carries at the provider's list price with nothing added, which is the cheap way to find out whether a workload justifies owning the hardware. Two caveats, stated rather than implied: this is a different model with different weights, and it is not a substitute for Kolibri's German pretraining depth. It is the honest comparison between a model you can rent and a model you have to own.

For a team weighing a sovereign deployment, there is a second reason to route rather than commit. If a workload is currently served by a hosted model and you are considering moving it onto self-hosted Kolibri, the useful test is running both against your own traffic, not reading two benchmark tables — and a routed endpoint with automatic failover is a lower-risk place to run that test than a production path you have already migrated.

Where Kolibri stands

Aleph Alpha has published an unusually complete account of a model — the training pipeline, the data provenance, the tokenizer method, the energy figure and a predecessor that was built and discarded — and shipped the weights under a licence a company can actually deploy under. For a German public-sector or industrial buyer whose procurement rules start with where the data lives, that combination is the product, and no benchmark row substitutes for it.

What a buyer cannot do yet is check the claims. There is no independent evaluation, no hosted endpoint, and no price to compare against anything else, which means the decision rests on the vendor's own numbers plus a self-hosted trial. That is a real limitation and it is not a reason to dismiss the model — it is the reason the specification above is worth reading line by line rather than skimming the percentages. If you want to understand what Kolibri is, the answer is a 78B open-weight, text-only, German-English MoE with a 1M-token ceiling and a two-GPU floor. Whether it is the right model for your workload is a question only your own evaluation can close.