Phonon refiner 1.7B

The correction model in Phonon, a local voice-typing app for Apple Silicon Macs. Phonon turns speech into a raw transcript with Parakeet TDT 0.6B v2. This model rewrites that transcript into the text the speaker meant to type: it fixes misrecognized words and technical terms, removes filler and false starts, keeps only the final version when the speaker corrects themselves, and formats the text for the app it is going to (writing modes, below). It is fine-tuned from LiquidAI/LFM3-1.7B on transcripts of public audio and on synthetic transcripts. No personal dictation went into it.

This is the refiner in Phonon 1.0. The 0.2.3 refiner is commit 74ea4b6 of this repository.

This repository holds what the app downloads on first launch:

Hugging Face shows each file's SHA-256 on its file page. The GGUF target and the drafter run on Phonon's native Metal engine (phonon_engine.json). The MLX weights (model.safetensors, config.json and the tokenizer files) are the same refiner, which the app loads when the engine cannot run on a Mac.

Writing modes

Phonon picks a mode from the app the text is going to (for a browser, from the site) and sends it as one line of the system prompt:

The rules in every mode:

• Fix misrecognized words and terms only with evidence: the vocabulary line or unambiguous context.
• Remove filler: hesitations, stutters, repeats, meaningless "like", "you know" and "I mean", tag questions, and sentence-opening linking words.
• Keep only the speaker's final version of a false start or a self-correction, without the correction words.
• Write digits and symbols the way an engineer types them.
• Never invent a word and never drop meaning.

Each mode then adds its own:

• casual: keeps the speaker's informal words, writes sentences in lowercase except names, acronyms and "I", and leaves off the final period.
• formal: writes complete sentences and fixes grammar slips without rephrasing. A dictated greeting and sign-off go on their own lines.
• prompt: keeps a revised or restated request once, in its final version. Separate steps become a numbered list. It never answers or extends the request.

Without a mode line the model behaves like the 0.2.3 refiner, because half of its training rows are that model's rows without a line.

Training data

• Writing-mode rows (38,480): targets in all four modes written by DeepSeek-V4.1-Flash-1017 (MIT license) from a written specification of the intended text (the rules above). These labels came from DeepSeek's hosted API; the 0.2.3 rows below were labeled by the same model running locally. Every target went through an edit gate that undoes word substitutions the transcript cannot support. The inputs are Parakeet TDT 0.6B v2 transcripts of three sources:
  • 3,000 chunks of the public technical audio below (11,467 rows);
  • 3,000 chunks of public programming livestreams, for conversational speech (11,428 rows);
  • 4,199 synthetic dictations written by the same model, such as requests to coding agents, chat messages, emails and notes, about half of them with a self-correction or a restart (15,585 rows).
• Rows of the 0.2.3 refiner (38,480, no mode line): its teacher-labeled chunks of public YouTube technical talks, tutorials and courses, plus term-repair rows and hard negatives. A term-repair row has a corrupted technical term in the input and a vocabulary line listing the true term; a hard negative has an unrelated vocabulary and must not change.
• Total: 76,960 rows. No audio is redistributed with these weights.
• Never used: the Phonon author's dictations, any user data, and the evaluation sets below. Videos used for evaluation were held out by video id, and the self-correction probe by shared 8-word phrases.
• Leak check: 3,036 evaluation texts were checked: the author's dictations, the bench sets, the lecture captions and the self-correction probe. No training input or target equals one of them, or contains half or more of one's 8-word phrases. The phrases that do appear in both are generic, for example "what we're going to do is we're going".

Recipe: a rank-16 LoRA on all linear layers of LFM3-1.7B (learning rate 2e-4, 2 epochs, batch 16, up to 1,024 tokens), merged into the weights, then quantized two ways:

• Engine target: GGUF Q4_K_S with a 4-bit token embedding and output head, and an importance matrix from the public training rows.
• Fallback: MLX 4-bit (group 64) with 6-bit attention and 8-bit embeddings, about 5.2 bits per weight.

Prompt format

Use the format the model was trained on, or quality drops:

• System: Rewrite the raw dictation transcript into the exact text the speaker intended. Fix recognition errors and technical terms, keep the speaker's wording and casing style, do not add or drop content.
  • Then one writing-mode line from the table above.
  • Then, optionally, Vocabulary the speaker may use: term1, term2, ..., the user's dictionary terms that may appear. Phonon sends 30 to 80, most confident first.
• User: the bare transcript.
• Decoding: greedy, thinking off (enable_thinking: false in the chat template), and no repetition penalty. The GGUF carries the base model's sampling defaults (temp 0.1, top_k 50), so pass --temp 0 to llama.cpp.
• Cap the output at 1.5 x input tokens + 32. Phonon also falls back to the raw transcript when the output has more than twice the input's words or, past 8 words, fewer than 0.4 of them.

Evaluation

Three lecturers, against their own captions

The recordings are 120 segments of 30 s: Jeremy Howard (fast.ai 2022, CC BY), Ana Bell (MIT 6.100L) and Charles Leiserson (MIT 6.172). None of the videos is in the training data. Each person's dictionary was mined from three to six of their other videos. Parakeet ran with that dictionary boosted, and the refiner got the vocabulary line Phonon builds.

The score is the share of words that differ from the creators' captions: Whisper normalizer, 1 s unscored at each edge, intervals from a paired bootstrap. Wispr Flow got the same dictionary through its API. Its outputs are from Nov 2, 2026.

Captions keep much of the filler and the false starts that this model removes, so it differs from them more than 0.2.3 does. Its extra differences are deletions (598 vs 398); it substitutes fewer words (110 vs 143) and inserts fewer (48 vs 84). The discourse-word column drops "so", "and", "like", "um" and the like from both sides; it was added after the first scoring.

A blind pairwise judge compared this model's output, in minimal mode, with Wispr Flow's on the same segments. The judge was Claude Opus 5.5, run on each pair in both orders; a verdict counts only when both orders agree. It was given the spec, plus the captions and both recognizers' raw transcripts as evidence.

It preferred this model on 90 of 119 segments, called 6 even, and preferred Wispr Flow on 23 (win rate 0.78). The 0.2.3 refiner scored 0.60 against Wispr Flow in the same comparison (64 / 16 / 40 of 120). These lecture numbers come from the f16 weights.

Self-corrections

The probe is 96 synthetic dictations, each revising one detail ("tuesday, actually no, thursday"). An output resolves an item when it keeps the final version and drops the abandoned one. The table shows the shipped Q4 GGUF on Phonon's engine on an M4 Max.

The 0.2.3 refiner was trained to keep every word, so it writes both versions. The probe was written by the same model that wrote the synthetic training dictations, with shared phrases removed, so this model's numbers are likely higher than on real speech. On the author's real dictations, explicit self-corrections are rare: 7 of 608.

Real dictations (one speaker)

These are the Phonon author's dictations. The references are derived from Wispr Flow's output, and the score is word error rate after the bench's fair normalizer. Both refiners got the same boosted Parakeet input and vocabulary line. The difference has a 95% interval from a paired row bootstrap (2,000 resamples).

The intervals include zero, so by this measure the two models cannot be told apart on this speaker.

On 608 of the same dictations, a local blind judge (Gemma 4 31B, both orders) judged each in the mode Phonon would pick for the app it was dictated into. Most went to terminals and code editors, so 552 were in prompt mode. Against Wispr Flow's text this model won 235, tied 209 and lost 164 (win rate 0.56). Against the 0.2.3 refiner it won 269, tied 279 and lost 58 of 606 (0.67). On 960 lecture judge requests that both judges answered, this judge's win rates were within 0.08 of Claude Opus 5.5's.

The fallback weights

The MLX fallback, run through Phonon's correction sidecar (mlx's CUDA backend, not a Mac), matched the GGUF's output on 296 of 384 probe requests. It resolved self-corrections at the same rates: 0.58 / 0.52 / 0.57 / 0.48.

Caveats, read these before quoting the numbers:

• The real dictations are from one speaker, mostly technical. They show how the model does on that workload, not on English speech in general. They stay private.
• Judges are models. The Opus judge reads the same written spec the labeler was given, so it rewards following that spec.
• The tables measure different weights: the lecture numbers are f16, the dictation and probe numbers the shipped Q4 GGUF.

Limitations

• Self-corrections: it resolves about half of them. When it misses one, it often leaves the whole sentence as spoken, filler included.
• It deletes more than 0.2.3. On the lectures it kept 92.8% of the captions' content words against 94.4% for 0.2.3 (Wispr Flow 90.9%). Some of that is repeated or abandoned phrasing, some is content.
• Not re-measured for this version: the 0.2.3 card's medical, synthetic new-term and false-insertion numbers.
• English only. Dictation-length inputs, up to about a minute of speech.
• It is a cleanup model, not an assistant. In prompt mode it rewrites the request and never answers it. Check its output before relying on it for medical, legal or other high-stakes text.

Intended use

Post-processing of speech-recognition output for dictation, run locally. Phonon downloads this repository pinned to a commit and runs it without network access afterwards.

Running it

• In Phonon: nothing to do. The app downloads this repository on first launch and picks the mode from the target app.
• llama.cpp: Phonon runs the GGUF through llama.cpp 39febd2 with Phonon's patch. Upstream builds with LFM3 support (since PR #31252, 2026-10-27) should load it, but that is untested. Use the chat template in the file, --temp 0, and the prompt format above.
• MLX: mlx-lm 0.31.3 has no LFM3 model. Add the model definition from mlx-lm PR 2016; Phonon ships it as sidecar/models/lfm3.py.
• The drafter (phonon-refiner-1.7b-dflash2-drafter.gguf) is the 0.2.3 release's DFlash2 block drafter: 3 layers, FFN 1024, a 24,576-token draft vocabulary, 7 drafted tokens per step, trained on the 0.2.3 refiner's outputs on public transcripts. With greedy verification the output is the target's own. On an M4 Max, through Phonon's sidecar and engine, all 384 probe requests (four modes) gave identical text with this drafter and with a different one, as greedy verification should. The drafter was trained on the 0.2.3 refiner's outputs, so this model drafts a little slower. On Phonon 0.2.4's engine (M4 Max, the same 384 requests, runs alternating) the refine step took 73 ms median and 91 ms p90, against 69 / 83 ms for the 0.2.3 refiner. On a busier second run it was 96 / 123 against 78 / 97 ms.
  • Its GGUF layout is read by Phonon's engine (pe, kind dflash2n) and by llama.cpp with Phonon's patch (--spec-type draft-dflash), not by stock llama.cpp.

License

The weights are a derivative of LFM3-1.7B and are distributed under the LFM Open License v1.0, as the base model is. In particular:

• Commercial use is licensed only to organizations with under 10 million US dollars in annual revenue (section 5). A larger organization's commercial use is not licensed by it.
• Redistributions must include the license and keep the notice that these files were modified (see NOTICE).
• "Liquid AI" and "LFM" are Liquid AI's names, used here only to describe the model's origin.

Phonon itself is GPL-3.0. Parakeet TDT 0.6B v2 is NVIDIA's, under CC-BY-4.0.