Can You Run Europe's Open 78B Yourself? — Kolibri-1 — The Sovereignty Question

Rent or own

78.1 billion. That’s the parameter count on Kolibri-1’s Hugging Face page, and it sounds like a model that belongs in a data center. On 3 October, Aleph Alpha, the German lab in Heidelberg, put the weights up under Apache 2.0: yours to keep, yours to run wherever you like.

The coverage called it no match for the open-weight leaders. On a leaderboard, maybe. The decision in front of a European buyer is different: can you run Europe’s open model yourself, on hardware you own? I did the arithmetic, then ran it on the Mac Studio on my desk. One number says no and another says yes.

Kolibri-1 is a mixture-of-experts model. Each of its 50 layers holds 384 small experts; for every token, a router picks six of them, and one shared expert always runs. That gives two numbers that never match: 78.1 billion parameters in total and 3.46 billion active per token. The total decides whether it fits. The active count decides how fast it runs once it does.

Does it fit?

Weights take parameters times bytes per parameter: 39 GB at 4-bit, 78 at 8-bit, 156 at full precision. Aleph Alpha ships 8-bit floating point and its model card puts the footprint at about 78 GB, which matches. Real files run larger because every group of 64 weights carries its own scale. The 4-bit builds I downloaded are 44 GB; the 8-bit is 83.

Then the key-value cache, the memory each conversation needs while the model reads. Of Kolibri’s 50 layers, 40 use a sliding window of 513 tokens, and only ten look at the whole context. That works out at 20 KB per token: about 5.4 GB at the 262,000 tokens Aleph Alpha recommends, and around 21 GB at the full million-token window the lab says it validated.

On the two reference rigs:

• RTX 5090, 32 GB. No. Even the 4-bit build is over the card before it reads a token. A 2-bit build at 25.5 GB fits on paper, but the community llama.cpp files need a patched build, and their readmes say Ollama and LM Studio can’t load them. I haven’t tested any NVIDIA route.
• Mac Studio Ultra, 256 GB (about 224 usable). Yes, by arithmetic: full precision plus a long document is 162 GB, with 60 to spare. I haven’t run it on an Ultra.

On my M2 Max with 96 GB, the 4-bit build read a 500-token prompt at 641 tokens a second and wrote at 63. At 32,000 tokens it wrote at 51 and peaked at 46 GB, and reading that prompt took about a minute before the first word appeared. Three community conversions wrote between 56 and 68 tokens a second. Different files, so that’s a range, not a ranking.

The 8-bit build is where the arithmetic and the machine disagree. The file is 83 GB and this Mac lets the GPU use about 83.5. I tried six times, three with my usual apps open and three with everything closed. Every attempt died between 76% and 98% of the way through loading, stopped by a watchdog I’d set to kill any load that pushed more than 2 GB into swap. Fitting on paper and running turned out to be different answers.

In May, I covered Mistral Medium 3.5, whose 4-bit build needed roughly 70 GB. Kolibri at 4-bit is 44, and per token it works through about 37 times fewer parameters than Medium 3.5’s dense 128 billion. A much smaller machine answers the same sovereignty question.

Does shrinking it change the answers?

I wrote 24 questions about eight synthetic contracts, twelve in German and twelve in English, with the answers written down before anything ran. The 4-bit, mixed and 2-bit builds all got 24 of 24, and every build declined all six questions the documents couldn’t answer. That doesn’t prove quantising is free. It proves my test was too easy: short extraction from a 400-token contract survives almost anything.

The port author’s own test is harder. It measures how often the shrunk model picks the same next word as full precision, and agreement fell from 0.931 on their mixed build to 0.845 on plain 4-bit, on one 612-token prompt. For anything beyond short extraction, run your own documents first.

Does owning it save money?

Anthropic’s pricing page, read on 5 October: Claude Haiku 4.5 at $1 per million tokens in and $5 out. Kolibri’s own tables put it against open models in the 30-to-120-billion class, which makes Haiku the fair comparison.

Self-hosting on a rented H200, at $3.50 an hour and 40% of its rated speed (both my assumptions), input costs about 1.7 cents per million tokens. Output is the expensive half, because every step pulls the weights through memory. Serving 32 requests at once gives about 2,000 tokens a second, or about 49 cents per million: ten times cheaper than Haiku with the card busy every hour, two and a half times at a quarter of capacity. The card still costs about $2,500 a month whether you use it or not, so the break-even sits near 500 million output tokens a month, before electricity and the engineer who keeps it running.

The Mac is a different shape. At 63 tokens a second, an hour of continuous writing is about 228,000 tokens, which Haiku would bill at $1.14. A Mac Studio doesn’t save money on this model. It keeps your data in the room.

What “European” means now

In April, Canada’s Cohere announced it would acquire Aleph Alpha. On 16 September the two signed a definitive agreement: a combined company valued around $20 billion, headquartered in Berlin and Toronto, with Heidelberg becoming a research center and Germany’s Schwarz Group providing €500 million. It still needs regulatory approval. Cohere’s chief executive, Aidan Gomez, told TechCrunch in April that “Cohere will become a Canadian German company.”

After 25 years in cybersecurity, I know what software escrow clauses are for: the moment the vendor you depend on changes hands. Open weights are escrow you can hold. Read what the license covers, though. The rights apply to the weights and configuration files in the repository. You don’t get the training data, the recipe or the next release.

Who it’s for

German or English work in a regulated sector, with contract archives or case files too big to send to a US cloud: test this one. The context runs to 262,000 tokens and the lab trained it to decline when the documents don’t support an answer. A small team with modest volume should stay on the API. Coding-agent work should test before moving, and sectors that won’t deploy a Chinese-origin model should ask how much accuracy a European, Apache-licensed alternative costs them. The model card doesn’t answer that.

The card does say what Kolibri isn’t for: autonomous systems without human review, and high-stakes decisions without added guardrails. Its knowledge stops on 18 June 2026.

One. Are you self-hosting or calling an API? The open-weights advantage exists only if the weights run on your hardware.

Two. What does your written data-residency requirement say? Pick the model after you know it.

Three. If your vendor were acquired next quarter, which of your workflows would still run the morning after?

You can own the weights. You can’t own the roadmap.