[!NOTE] Update 2026-07-15: gpu-pipelined-b2/ adds lfm2_5_1_2b_instruct_decode_int8hu_block32_sym re-exported with coreai-core 1.0.0b2, loadable on the OS 27 beta 3 toolchain (June-era b1 bundles fail to load there with a versioned-IR error). The original b1 tree is retained unchanged so existing apps and pinned catalogs keep working. The b2 decode bundle is the exact artifact measured on DeviceMark.

LiquidAI's LFM2.5-1.2B-Instruct converted to Apple's Core AI (the Core ML successor announced at WWDC26), ready to run on iOS 27 / macOS 27. A conv + full-attention hybrid (10 short-conv mixers + 6 GQA attention layers) riding Apple's coreai-pipelined GPU engine — the first non-Qwen architecture on that fast path, with zero custom kernels.

Requires the iOS 27 / macOS 27 beta (Core AI ships with the OS). Conversion code, knowledge base, and the Swift runner: coreai-model-zoo.

Use it

⚡ One line — run the kit's task op on this model (import CoreAIOps; no session, no model plumbing, downloads on first use):

let tldr = try await CoreAI.summarize(text, options: .model("lfm2.5-1.2b"))

Every op, one shape — Cookbook.

▶️ Run it (source) — the ChatDemo runner (GUI + CLI, one app for every chat model in the catalog):

bash

git clone https://github.com/john-rocky/coreai-kit
open coreai-kit/Examples/ChatDemo/ChatDemo.xcodeproj
# → Run, then pick "LFM2.5 1.2B" in the model picker

# agents / headless (macOS):
cd coreai-kit/Examples/ChatDemo
swift run chat-cli --model lfm2.5-1.2b --prompt "What can you do, offline?"

💻 Build with it — complete; the glue is kit API, copy-paste runs:

swift

import CoreAIKit

let chat = try await ChatSession(catalog: "lfm2.5-1.2b")
let reply = try await chat.respond(to: prompt)
// reply: the answer, generated fully on-device

Also runs behind Apple's FoundationModels API — CoreAIKit's KitLanguageModel plugs this bundle into the system LanguageModelSession; capabilities (tool calling, guided generation) auto-detect per model.

The take-home is Examples/ChatDemo/Sources/QuickStart.swift — this exact code as one typed function, no UI; the CLI is an argument shell over it, and the GUI drives the same ChatSession across turns for its transcript. Multi-turn? Hold the ChatSession and call respond(to:) per turn — it keeps the conversation history; streamResponse(to:) yields tokens as they decode.

Integration checklist

SPM: https://github.com/john-rocky/coreai-kit → product CoreAIKit
Info.plist: none needed
Entitlements: none needed
First run downloads the model — 1.6 GB (Mac) / 1.6 GB (iPhone) — then it loads from the local cache (Application Support; progress via the downloadProgress callback)
Measure in Release — Debug is ~3× slower on per-token host work

Measured (greedy; single-step top-1 gated 16/16 vs the fp32 Hugging Face oracle)

Surface	Bundle	Prefill	Decode
M4 Max, release `llm-benchmark`	★★★ `gpu-pipelined/lfm2_5_1_2b_instruct_decode_int8hu_block32_sym/` (1.6 GB)	277.8 tok/s	276.5 tok/s
iPhone 17 Pro, one-shot runner	★★★ same bundle	44.2–46.6	44.1–46.6 tok/s
M4 Max, release `llm-benchmark`	★★ `gpu-pipelined/lfm2_5_1_2b_instruct_decode_int8lin/` (1.5 GB)	253.3 tok/s	253.3 tok/s
iPhone 17 Pro, one-shot runner	★★ same bundle	39.2–39.4	38.0–39.6 tok/s
iPhone 17 Pro, chat app (CoreAIChat LFM mode, 200-tok turn)	int8lin bundle	30.7	35.8 tok/s

★★★ = the ship config (int8hu_block32_sym): int8lin + the tied lm_head untied and quantized absmax per-block-32 int8 (symmetric, no clipping — clipping corrupts big-vocab heads). +9% on M4 Max, +15–20% on iPhone (44.1–46.6 ≈ ~94–98% of the naive bandwidth ceiling, ~60 GB/s ÷ ~1.27 GB/token); warm engine load 0.3 s. Greedy rollouts are token-identical to the int8lin bundle on both verification prompts; oracle gate 16/16 + decode step, device numerics 24/24 ≡ Mac-GPU on all 3 runs.
★★ int8lin: the fp16-head variant (what CoreAIChat currently downloads); ~87% of its ceiling on iPhone. Cold GPU specialization 6.8 s, warm load 1.6 s; no AOT compile needed.
iPhone greedy sequences are 24/24 token-identical to the M4 Max GPU on both fixed verification prompts (both bundles).
For scale: our Qwen3.5-0.8B on the same engine does 210 tok/s on M4 Max — this 1.2B does 276.5.

What the bundle is

One full LanguageBundle (.aimodel + tokenizer/ + metadata.json): decode-only graph, input_ids static [1,1], position_ids + KV seq dynamic (→ the engine factory selects coreai-pipelined: async non-blocking encode, on-GPU argmax sampling, on-device KV growth). Weights are int8 linear per-block-32 (scale-multiply dequant — no LUT; k-means LUT gathers measure slower on this GPU delegate) with the embedding, depthwise convs, norms, and the four attention projections kept high-precision; in the ★★★ bundle the lm_head is untied and quantized absmax per-block-32 int8 too (in the ★★ bundle it stays fp16/tied). Do NOT re-quantize the head per-channel: per-channel (axis-0) int8 weights are broken on the current beta GPU delegate (garbage logits — delegate lowering bug, documented in the zoo knowledge base). The attention projections are fp32 on purpose: under a dynamic-shape graph the delegate's fp16 attention-prologue matmuls lose ~1.3% relative accuracy, which LFM2.5's large q/k-norm gains amplify into wrong logits — fp32 there restores layer-level exactness (+126 MB). Full write-up: knowledge/pipelined-engine.md.

Run it

bash

git clone https://github.com/john-rocky/coreai-model-zoo
git clone https://github.com/apple/coreai-models
git -C coreai-models apply ../coreai-model-zoo/apps/coreai-shared-product.patch \
                           ../coreai-model-zoo/apps/coreai-pipelined-extra-states.patch
# (the extra-states patch lets the engine carry the conv state as a fixed-shape extra state)

# download this bundle into coreai-models/exports/, then:
cd coreai-models && swift build -c release
COREAI_CHUNK_THRESHOLD=1 ./.build/release/llm-benchmark \
    --model exports/lfm2_5_1_2b_instruct_decode_int8hu_block32_sym -p 128 -g 256 -n 3

Run contract (each of these matters):

COREAI_CHUNK_THRESHOLD=1 before engine creation — prefill must run as pipelined S=1 steps (prompt tok/s ≈ decode tok/s).
Never call engine.warmup() on this S=1 bundle (it warms query length 256, which the static [1,1] graph rejects). A 1-token generate after load is the warmup; llm-runner needs --warmup exact --warmup-length 1.
Benchmark Release builds only (a Debug engine measures ~3× slow).

On iPhone, the CoreAIChat sample app has an LFM picker mode that downloads this repo in-app and chats through this bundle.

Conversion

Reproducible with conversion/export_lfm2_decode_pipelined.py (+ the models/macos/lfm2.py overlay) from the upstream HF checkpoint. Numerics are gated the strict way: a teacher-forced S=1 sweep over a 16-position oracle prompt (top-1 vs the fp32 HF reference at every position, 16/16 required) plus an oracle-cache-seeded decode step — not long-rollout eyeballing. Model card with the full method and the GPU-delegate findings: zoo/lfm2.5.md.

License

The model weights derive from LiquidAI/LFM2.5-1.2B-Instruct and are redistributed under the LFM Open License v1.0 (see LICENSE): Apache-style grants, but Commercial Use is licensed only for entities below US$10M annual revenue (qualified non-profits exempt for non-commercial/research use). The conversion code is BSD-3-Clause (zoo repo).

More models in this format: Core AI Model Zoo — 75 models, each with the recipe that produced it.

Want a different model on-device? Open a request — free, open weights only; the export and its measured numbers get published publicly.

mlboydaisuke/LFM2.5-1.2B-CoreAI

LFM2.5-1.2B-Instruct — Apple Core AI (.aimodel)