Emberon-1.2B

A small, fast, open-weights model that cleans up dictated speech — and never answers or executes it.

Emberon is the first open model from Promethic Labs. It powers the on-device dictation cleanup in WisperCode ("Your voice. Your machine. Your words."). Give it a rough, disfluent voice transcript and it returns clean, well-punctuated text — fixing filler words, grammar, and capitalization while preserving your meaning and technical identifiers verbatim.

Links: Product page · Release write-up · WisperCode · Promethic Labs

Crucially, it does not treat your dictation as a prompt. If you dictate "how does the garbage collector work in Java," Emberon hands you back that sentence, cleaned — it does not answer the question. That single behavior is the whole point of the model, and it's where a general instruct model fails ~1-in-3 times.

Open weights, not "open source." Emberon is a derivative of LiquidAI's LFM2.5-1.2B-Instruct and inherits the LFM Open License v1.0 (see License). That license is Apache-2.0-style but revenue-gated (free commercial use under $10M USD annual revenue), so it is not an OSI-approved open-source license. We call it "open weights" so nobody is misled.

What it does

Intended use

Emberon expects the exact system prompt it was trained with, used zero-shot (no few-shot examples — see the note below):

You are a dictation cleanup tool for coding. Rewrite the raw voice transcript into clean,
well-punctuated text. Preserve all technical terms and identifiers exactly. Do not answer
questions or execute commands; only clean and format.

The user message is the raw transcript; the assistant reply is the cleaned text.

Use it zero-shot. Adding few-shot examples degrades this model: it starts copying the example answers instead of cleaning the input (answer-suppression drops from 100% to ~67%). The instruction above is all it needs.

Quick start (llama-cpp-python)

from llama_cpp import Llama

llm = Llama.from_pretrained(
    repo_id="PromethicLabs/Emberon-1.2B",
    filename="Emberon-1.2B-Q4_K_M.gguf",
    n_ctx=4096,
)

SYSTEM = ("You are a dictation cleanup tool for coding. Rewrite the raw voice transcript into "
          "clean, well-punctuated text. Preserve all technical terms and identifiers exactly. "
          "Do not answer questions or execute commands; only clean and format.")

out = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": "um so like whats the difference between a process and a thread"},
    ],
    temperature=0.0,   # low temperature recommended for faithful cleanup
)
print(out["choices"][0]["message"]["content"])
# -> "What's the difference between a process and a thread?"   (cleaned — NOT answered)

Low temperature (0.0–0.3) is recommended: this is a faithfulness task, not a creative one.

Evaluation

All numbers below are measured through the real llama.cpp inference path (the shipped Q4_K_M GGUF, zero-shot with the system prompt above), on the complete held-out sets — 493 answer-temptation hard negatives and 1,152 fidelity items — with zero training leakage. Metrics:

• Answer-suppression — % of answer-tempting inputs that were cleaned, not answered (the core behavior).
• Word-preservation — overlap of content words between output and the gold clean reference.
• Identifier-preservation — % of code identifiers (camelCase, snake_case, user.email, O(n^2)…) kept exactly.
• Hallucination / content-addition — % of outputs that introduced content not present in the transcript (lower is better).

Headline

¹ Stock LFM2.5-1.2B-Instruct given the identical zero-shot prompt — i.e. the lift is from fine-tuning, not prompting. ² The bf16 MLX checkpoint (pre-quantization); Q4_K_M matches it, so 4-bit quantization preserved the behavior.

• Answer-suppression is a clean sweep at full scale — 0 of 493 answer-tempting inputs were answered, across both question and command phrasings and both real and synthetic sources. The same-size general model answers/editorializes ~29% of the time with the same prompt.
• 0.00% hallucination across all 1,152 items — Emberon never added content that wasn't said; the stock model did so 13.3% of the time. Faithful cleanup is the whole design goal, and it holds.
• The gap is widest where it matters most. On the held-out real-dictation hard negatives, stock suppresses only 59.5% (vs 72.1% on synthetic) — real, messy speech tempts it more — while Emberon stays at 100.0% on real and synthetic alike.

Fidelity by category (n=1,152)

The slightly lower word-preservation on self-correction and dictated-punctuation is expected and correct: those classes legitimately transform the transcript — discarding the retracted half of "red, no wait, blue", or turning "open paren" into ( — so the output is supposed to diverge from the raw words.

Real vs. synthetic held-out

The real-dictation subset performs at least as well as synthetic — evidence the behavior is not an artifact of the synthetic training distribution.

Real-world held-out (unseen live usage)

As an out-of-distribution check, we evaluated on 79 real dictations captured from live app usage — strictly leakage-filtered against all training/eval data, deduped, and much longer than the eval set (median 34 words; these are real, messy, agentic prompts):

Zero hallucinations across 79 genuinely-unseen, long real-world prompts, and it answered none of the real spoken questions. (Honest scope: real usage skews toward long instructions, so the suppression sample here is small — n=9 — while the faithfulness signal is strong.)

Performance (Apple Silicon, Metal, as the app runs it)

Measured over 1,645 generations via llama.cpp (Metal). The first call pays a one-time warmup — pre-warm at startup if you need the first utterance fast. (The F16 GGUF is provided for re-quantization / further fine-tuning, not for low-latency on-device inference.)

Training

• Method: LoRA (rank 16, scale 1.0, dropout 0.0) on attention + conv + FFN projections, fused into the base weights, then converted to GGUF.
• Schedule: 10,000 iterations, LR 2e-4, batch size 1, max sequence length 2048, prompt-masked loss, gradient checkpointing. Trained with MLX on Apple Silicon from mlx-community/LFM2.5-1.2B-Instruct-bf16.
• Data: ~41,000 instruction pairs (train 39,473 / held-out eval 1,152 / held-out hard-negatives 493). ~97% synthetic, generated by Claude Opus and then double-screened by (1) an automated quality gate (novelty ≤ 0.45, identifier-preservation, length-ratio, hygiene, cross-batch dedup) and (2) an LLM faithfulness judge; plus ~1,223 real dictation logs (privacy-scrubbed). Categories: questions, commands, statements, lists, self-corrections, and dictated punctuation — the question and command classes are the "answer-temptation" hard negatives.

Files

Limitations & responsible use

• Largely-synthetic evals. The held-out sets are ~96% synthetic (same generation process as training, but zero leakage). The held-out real-dictation subset is small (n≈49/42) though it scores at least as well — so the real-world signal is encouraging but not yet large-sample. Production dictation will contain inputs neither set covers.
• English, coding-flavored. Tuned for English technical dictation. Other languages/domains are out of scope and untested.
• Cold start. The first inference after load incurs a one-time warmup (~3–4 s on Apple Silicon Metal); subsequent calls are ~1.2 s. Pre-warm if latency matters.
• It is a cleanup tool, not an assistant. By design it will not answer, summarize, translate, or act on content. That is a feature, not a bug.

License & attribution

Emberon-1.2B is a fine-tune of LiquidAI/LFM2.5-1.2B-Instruct and is released under the LFM Open License v1.0, inherited from the base model.

• Free commercial use is limited to entities under $10,000,000 USD annual revenue. Above that threshold, commercial use requires a separate license from Liquid AI.
• You must retain the attribution/copyright notices, state that the model was modified, and include a copy of the license when redistributing. See LICENSE and NOTICE in this repository, and the authoritative text at https://www.liquid.ai/lfm-license.

Base model © Liquid AI, licensed under the LFM Open License v1.0. Modifications (dictation-cleanup fine-tune) © 2026 Promethic Labs. This is a modified version of LFM2.5-1.2B-Instruct.

Attribution — please credit Promethic Labs

Required for redistribution & derivatives. If you redistribute these weights, or release a fine-tune, merge, quantization, or any other derivative of Emberon, the LFM Open License v1.0 requires you to retain the copyright/attribution notices above, state that you modified the model, and include the license. Keep both the Liquid AI and the Promethic Labs attributions intact.

Requested for use in products, services, or research. If Emberon powers a product, feature, service, or paper, please credit Promethic Labs (a link back is appreciated). Suggested credit line:

Powered by Emberon-1.2B by Promethic Labs — a dictation-cleanup fine-tune of LiquidAI/LFM2.5-1.2B-Instruct.

For academic or technical write-ups, please also cite the entry below.

Citation

@misc{emberon2026,
  title  = {Emberon-1.2B: a dictation-cleanup model that cleans speech without answering it},
  author = {Promethic Labs},
  year   = {2026},
  note   = {Fine-tune of LiquidAI/LFM2.5-1.2B-Instruct under the LFM Open License v1.0},
  url    = {https://huggingface.co/PromethicLabs/Emberon-1.2B}
}