Embla 1: A Reasoning Model That Runs on Your Phone — Private, Offline, and Genuinely Fast

AI disclosure: This article was drafted with AI assistance and checked against Sevren's own launch blog and architecture post, read 15 November 2026. I have not run Embla 1 hands-on — nobody outside Sevren has had it long enough. Nothing here is sponsored, and there are no affiliate links on this page.

Sevren, a Copenhagen startup, has released Embla 1: a reasoning model designed to run entirely on a phone. Private, offline, and free per request — no API call, no server round-trip, no per-token bill. If that sounds like the pitch every on-device model makes, the difference here is the evidence Sevren published alongside it: a full architecture write-up, a training recipe, and benchmark numbers measured on an actual iPhone, including the places where their model loses.

That last part is why this launch is worth your attention. Most small-model launches hand you a cherry-picked leaderboard. Sevren handed us their model's weaknesses too.

What Embla 1 actually is

Embla 1 is a 10-billion-parameter mixture-of-experts model with only about 1 billion parameters active per token (that's the "A1B" in its size class). It's a reasoning model — it thinks through problems step by step before answering — built from the ground up for phone hardware rather than shrunk down from a server model.

The headline numbers, all measured by Sevren at 4-bit precision:

• 57.4 average across five benchmarks: BFCL (tool use), IFBench (instruction following), AA-Omniscience, GPQA (graduate-level science questions) and MATH-500.
• 1.77 seconds end to end on an iPhone 18 Pro for a 1,024-token prompt producing 256 output tokens, using Sevren's own Metal implementation. In llama.cpp the same task takes 2.18 seconds.
• 888 tokens per answer on average — the fewest of any reasoning model Sevren tested. The next-cheapest, Gemma 4 E4B, needed 1,577 tokens for the same answers. Qwen3.5-4B needed 6,619.

That last number is the one developers should care about most. On a phone, every token costs battery and time. A reasoning model that reaches a good answer in 888 tokens instead of 6,600 is not a little faster — it's a different class of product. It's the difference between an assistant that feels instant and one that makes you watch a spinner.

The honest caveats (read these first)

Sevren's numbers are Sevren's numbers. They say so themselves, and the caveats matter:

• Self-measured, one phone, one harness. All benchmarks were run by Sevren on a single iPhone 18 Pro, with an uncertainty of about ±1 point per average. Other setups may rank the models differently. No independent lab has verified these results yet.
• Five of the twelve models Sevren tested scored higher. LFM2.5-8B-A1B is 1.4 points ahead (58.8 vs 57.4) — but takes twice as long. LFM2.5-2.6B, Granite 4.2 3B, Gemma 4 E4B and Qwen3.5-4B are 2.6 to 5.3 points ahead, but take 3.0 to 5.5 times as long. Embla 1 trades a few points of accuracy for a large speed advantage. Whether that trade is right depends on what you're building.
• Math is the weak spot. Embla 1 scores 76.1 on MATH-500, against 89.6 for LFM2.5-8B-A1B and 90.5 for LFM2.5-2.6B. Sevren says it plainly: "There is still a lot to improve." If your app leans on hard math, this is not your model yet.
• The latency claim depends on Sevren's own runtime. The 1.77-second figure uses their custom Metal implementation. In the standard llama.cpp runtime it's 2.18 seconds — still fast, but the headline number is tied to their code, not just their weights.

None of that makes the launch unimpressive. It makes it checkable — and that's rarer than it should be.

Why it's fast: the architecture in plain language

Embla 1 is 32 layers, 2,048 wide, with 8 of 96 routed experts plus one shared expert active per token. Four design choices do most of the work:

• Sevren Sparse Attention. The full-attention layers use ReLU² instead of softmax, which makes about 95% of attention weights exactly zero — and decoding simply skips those values. Sparse attention layers (12 of the 32) keep no key-value cache of their own; they read from the preceding full-attention layer.
• K/V bridges. After layer 15, bridges build every second-half cache, so prefill skips layers 16 to 31 entirely. Prefill is usually the slow part on a phone; this is where much of the speed comes from.
• Engram. The last two or three tokens are hashed into a 3-billion-parameter table, and the rows they hit form a second input alongside the token embedding at every layer — a kind of working memory baked into the weights.
• Quantization-aware training. The last 2,000 steps of supervised fine-tuning run in the phone runtime's exact 4-bit format, so the model is trained for the precision it will actually run at — not trained in high precision and squeezed afterwards.

The training itself is Denmark's largest AI training project to date, run on the Gefion supercomputer: 1.4 trillion tokens of pretraining (distilled from Qwen3.5-35B-A3B-Base), a 20-billion-token extension to 256K context, 123 billion tokens of supervised fine-tuning, then on-policy distillation, GRPO reinforcement learning, and a final multi-teacher distillation stage. The tokenizer is Qwen3.8's, pruned to a 65,536-token vocabulary. Training ran on 16 nodes of 8× H100 GPUs.

What this means for developers

On-device reasoning stops being a demo. The practical barrier to phone AI has never been "can a model run on a phone" — it's been "can it reason well enough, fast enough, and cheaply enough that users don't notice the difference." Embla 1's answer is a genuine one: tool use (BFCL) and instruction following (IFBench) are exactly the capabilities an on-device assistant needs, and it does them in under two seconds with no network.

Privacy becomes a feature you can ship, not a promise you make. Because the model runs offline on the device, prompts never leave the phone. For health, finance, legal and journaling apps — anywhere users type things they'd never send to a server — that's the difference between a feature you can build and one your lawyers won't let you.

Free per request changes the economics. No API bill per call means features that were too expensive to offer — summarising every message, reasoning over every document, an assistant that thinks before every reply — become viable at any scale, including for indie developers and free-tier apps.

The 4-bit weights are on Hugging Face now. You can download them today and try them in llama.cpp (2.18 seconds for the reference task above) or in Sevren's own runtime. That's the fastest way to form your own opinion: run the same prompts you'd run in production and see whether the speed-accuracy trade works for you.

What's not here yet

• No independent benchmarks. Treat the 57.4 average as a claim to verify, not a fact. The first third-party evaluations will tell us how much of this holds up outside Sevren's harness.
• No word on Android performance. All latency figures are iPhone 18 Pro. What this looks like on a mid-range Android phone is an open question — and that's where most of the world's phones are.
• Math lags the field. If your use case is quantitative reasoning, the 76.1 MATH-500 score says to wait for the next version or pick a slower, stronger model.
• A phone model is still a small model. Embla 1 won't replace a frontier model for open-ended research or hard coding tasks. Its job is the everyday reasoning a phone does a hundred times a day — and that job is big enough.

My take

On-device AI has had a credibility problem: every launch claims "frontier quality on your phone," and almost none of it survives contact with real benchmarks. Embla 1 is different in the way that matters — Sevren published the architecture, the training recipe, the full comparison table, and the weaknesses. A company that tells you its model is behind on math and shows you exactly which competitors beat it is a company that expects you to check its work.

The bet here is clear: a few points of benchmark score are worth trading for 2–5× speed and the fewest tokens per answer in its class. For an on-device assistant, I think that's the right trade. The phone in your pocket doesn't need the smartest model in the world — it needs a good model that answers before you've lost patience, without sending your words to a server.

Download the weights, run your own prompts, and see if the trade holds for what you're building. That's the test that counts — and Sevren, to their credit, made it possible on day one.

Have you tried running a reasoning model on-device yet — and what would you build if the model were free per request?

Sources: Sevren — "Embla 1: A reasoning model built for phones" (https://www.sevren.ai/blog/embla-1) and "The Architecture of Embla 1" (https://www.sevren.ai/blog/embla-1-architecture); Øresund Startups — "Sevren releases Embla, its most efficient AI model that runs on a phone" (https://oresundstartups.com/sevren-releases-embla-its-most-efficient-ai-model-that-runs-on-a-phone/); EU-Startups — "Copenhagen AI startup Sevren launches Embla, claiming most efficient on-device AI model for smartphones" (https://eustartups.news/copenhagen-ai-startup-sevren-launches-embla-claiming-most-efficient-on-device-ai-model-for-smartphones/). All capability, benchmark and latency claims are Sevren's own measurements, stated as such; no independent verification and no hands-on testing was performed for this article. This breaking article is not the daily buyer-intent post, and it contains no affiliate links.

FAQ

What is Embla 1?
Embla 1 is a reasoning model from Copenhagen startup Sevren, released 15 November 2026, built to run entirely on a phone — private, offline, and free per request. It is a 10-billion-parameter mixture-of-experts model with about 1 billion parameters active per token, and its 4-bit weights are available on Hugging Face.

How fast is Embla 1 on a phone?
In Sevren's own measurements, Embla 1 answers a 1,024-token prompt with 256 output tokens in 1.77 seconds end to end on an iPhone 18 Pro using Sevren's Metal implementation (2.18 seconds in llama.cpp). It also uses the fewest tokens per answer of any reasoning model Sevren tested — 888 on average, versus 1,577 for Gemma 4 E4B and 6,619 for Qwen3.5-4B.

How good is Embla 1 on benchmarks?
Sevren reports a 57.4 average across BFCL, IFBench, AA-Omniscience, GPQA and MATH-500 at 4-bit precision. These are self-measured results on one phone with about ±1 point of uncertainty, not independently verified. Five of the twelve models Sevren tested scored higher, but all of them took at least twice as long. Embla 1 is notably behind on math: 76.1 on MATH-500.

Can I run Embla 1 myself?
Yes — the 4-bit weights are published on Hugging Face. You can run them in llama.cpp or in Sevren's own phone runtime. No API key and no server are needed, and there is no per-request cost.

Why does on-device AI matter for developers?
Because prompts never leave the phone, on-device models make private-by-design features possible for health, finance, legal and journaling apps — and because there is no per-request API cost, features that were too expensive to offer at scale become viable, including for indie developers and free-tier apps.