Sevren, an AI lab that publishes its work on the sevren.ai blog, has released Embla 1, a reasoning model designed for handsets that works without a network connection. At 4 bits, the model averages 57.4 across five benchmarks and finishes an answer in 1.77 seconds on an iPhone 18 Pro. The pitch is speed first, with accuracy a close second.

The five benchmarks are BFCL, IFBench, AA-Omniscience, GPQA and MATH-500, with reasoning enabled and answers capped at 16K tokens. Sevren compared Embla 1 against twelve small models, all quantized to 4 bits. The rivals came from Google, IBM, Liquid AI, Alibaba and OpenBMB. Latency was measured on one phone with a 1,024-token prompt and 256 generated tokens.

Five of the twelve beat Embla 1 on the average. LFM2.5-8B-A1B, from Liquid AI, leads by 1.4 points and needs 2.0 times as long. LFM2.5-2.6B, Granite 4.2 3B, Gemma 4 E4B and Qwen3.5-4B lead by 2.6 to 5.3 points and take 3.0 to 5.5 times as long. Gemma 4 E4B, for example, scores 60.4 and needs 9.53 seconds, against 1.77 for Embla 1.

One reason for the gap is verbosity. Reasoning models spend tokens thinking before they answer, and on a phone every token costs battery and time. Embla 1 averages 888 tokens per answer, the lowest among the reasoning models Sevren tested. Gemma 4 E4B averages 1,577, and Qwen3.5-4B averages 6,619, which is 7.5 times as many.

The speed also leans on software. Sevren decodes Embla 1 with its own Metal implementation, the route Apple’s GPU stack offers. Run through llama.cpp, the same model takes 2.18 seconds. Every competitor was tested in llama.cpp, so part of the lead comes from the runtime and not only the weights, a gap Sevren discloses in a footnote.

Embla 1 is also weak where small models often shine. It scores 76.1 on MATH-500, while LFM2.5-8B-A1B reaches 89.6 and LFM2.5-2.6B reaches 90.5. Sevren states plainly that there is a lot left to improve.

Under the hood, the model has 32 layers and routes each token to 8 of 96 experts plus one shared expert. Sevren trained it on 16 nodes of 8 H100 GPUs, starting with 1.4T tokens of pretraining distilled from Alibaba’s Qwen3.5-35B-A3B-Base. Quantization-aware training came late in fine-tuning, so the 4-bit weights are the ones that were tuned, not a compressed afterthought. Those weights are available on Hugging Face.

The numbers carry limits, and Sevren lists them. The figures are the lab’s own, taken on a single handset with a single test harness. Sevren puts the error on each average at roughly 1 point either way, and warns that a different setup could reorder the field. No outside group has reproduced the results.

The market angle is simple. An answer that arrives in under two seconds, with no server call and no per-request bill, changes which features a mobile team can afford to ship. Assistants that run on the device also keep user text off a vendor’s servers, which matters for apps that handle sensitive data.

Teams building on-device features should run their own prompts through the 4-bit weights this month. If Embla 1 holds its latency on their workloads and their math needs are light, the 1.4 to 5.3 point accuracy gap may cost less than waiting several seconds per answer.

Sevren, “Embla 1: A reasoning model built for phones,” Sevren blog (sevren.ai), published November 13, 2026.