S1-mini: Superwhisper's 0.6B On-Device Transcript Cleaner

Superwhisper just open-weighted its first language model, and the replies on X immediately asked the wrong question: how does this compare to Parakeet TDT v3, and is it worth switching?

S1-mini is not a speech-to-text model. It is a 0.6B Qwen fine-tune that sits after ASR and rewrites the messy transcript into something you would actually paste into Slack. Superwhisper's August 19, 2026 announcement called it a language model that "processes transcripts entirely on your device." That wording is exact. It processes transcripts, not audio.

TL;DR

What people are actually asking

The launch thread mixed three different products into one comparison:

1. Parakeet TDT v3 — NVIDIA's streaming/non-streaming ASR. This is what FluidVoice and Meetily already run on-device to turn audio into words.
2. Cohere Transcribe — another ASR backend (14 languages in FluidVoice's model picker). Same layer as Parakeet.
3. S1-mini — a tiny LM that takes those words and makes them look written.

Worth switching? There is nothing to switch. If Parakeet is dropping words, change the ASR. If Parakeet is fine but the transcript still reads like a court stenographer on a caffeine crash — so um i need to like send the the report by uh friday no wait make that thursday — that is S1-mini's entire job. The model card's own output for that line: I need to send the report by Thursday.

Where it sits in the stack

audio ──▶ ASR (Whisper, Parakeet, …) ──▶ S1-mini ──▶ clean text

That is the same slot occupied by:

• Fluid Intelligence inside FluidVoice — a ~3.5 GB closed local enhancement runtime for formatting and capitalization
• Cloud "rewrite my dictation" passes in paid apps like Wispr Flow
• The real-time transcript-cleanup use case Mercury 2 was built to serve, except Mercury 2 is a hosted diffusion API, not a 462 MiB file on your laptop

S1-mini is the open-weights, on-device version of that second stage. At 0.6B it is closer in spirit to LFM2.5's on-device specialist models than to a general chat LLM: one transformation, greedy decoding, no personality.

If you already run Hugging Face's speech-to-speech stack (Silero VAD → Parakeet TDT → LLM → Qwen3-TTS), S1-mini is an optional pass between STT and the LLM — or between STT and the UI, if you only wanted captions, not an agent.

S1-mini vs the models people named

For most local setups we have already recommended Parakeet v3 over Whisper large-v3 as the default ASR. S1-mini does not change that recommendation. It gives you a cheap, private inverse-text-normalization head to bolt on.

How you steer it (the control line)

This is not a chat model. You do not prompt it with "please make this more professional." You send a fixed system prompt plus a control line, then the raw transcript. Skip either piece, change the wording, or send a value it was not trained on, and the model card warns it can hallucinate or emit garbage.

[Styling: VALUE] [Structure: VALUE] [Context: VALUE]
raw transcript

The same input under all four registers, from the model card:

Input: hmm im gonna be late theres a cute dog outside i cant just walk past him

Filled pauses (um, uh) are removed in every register. Apostrophes are decided by the register, so im and I'm on the input side converge.

That control surface is the reason a 0.6B specialist can beat a general 7B "please clean this transcript" prompt: the task is closed. Greedy decode, temperature 0, output length tracks input length. The card's ceiling formula is 1.3 × input_tokens + 32. Chunk above ~1,000 tokens at sentence boundaries.

How to run it today

Weights live on Hugging Face as superwhisper/s1-mini (BF16, pin revision="v1"). GGUF builds are superwhisper/s1-mini-GGUF (s1-mini-q4_k_m.gguf and an F16). Transformers older than 4.51.0 will throw KeyError: 'qwen3'.

Python, from the model card — system prompt and enable_thinking=False are not optional:

from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL = "superwhisper/s1-mini"
tok = AutoTokenizer.from_pretrained(MODEL)
model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype="auto")

SYSTEM = (
    "You are a text normalizer for speech-to-text transcripts. The input begins "
    "with a control line specifying the styling, structure, and context settings; "
    "clean the transcript to match those settings and output only the cleaned text."
)

def normalize(transcript, styling="semi-formal", structure="prose", context="general"):
    control = f"[Styling: {styling}] [Structure: {structure}] [Context: {context}]"
    messages = [
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": f"{control}\n{transcript}"},
    ]
    text = tok.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True,
        enable_thinking=False,
    )
    inputs = tok(text, return_tensors="pt").to(model.device)
    out = model.generate(**inputs, max_new_tokens=1024, do_sample=False)
    return tok.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)

print(normalize("so um i need to like send the the report by uh friday no wait make that thursday"))
# I need to send the report by Thursday.

llama.cpp (do not substitute --reasoning-budget 0 — the card says that suppresses the think block a different way and degrades output):

llama-server -hf superwhisper/s1-mini-GGUF:Q4_K_M \
  --jinja --chat-template-kwargs '{"enable_thinking":false}' --temp 0

Same thinking-off requirement on vLLM / SGLang via chat_template_kwargs, and on Ollama / LM Studio, which inherit Qwen3's thinking-on-by-default template. If you already run GGUFs through llama.cpp or Ollama, this is another small specialist next to your coding model, not a new stack.

The blank-output bug (and the blank-output feature)

Qwen3's chat template turns thinking on by default. S1-mini was trained with thinking off and has no reasoning traces in its data. Leave the flag out and you usually get no usable output: an empty think block, then stop. The assistant prefix the model actually saw in training is an empty think block — two newlines inside, two after.

Separately, filler-only input is supposed to return "". Treat empty as a valid result in your pipeline or you will page yourself every time someone says "uh" into a hotkey.

License catch, and the other S1-mini

Apache 2.0 is the Qwen3-0.6B inheritance. Superwhisper adds one extra term: wherever the model is used, it must keep the name "S1-mini" by "Superwhisper", exact capitalization. That is closer to a trademark-in-the-LICENSE trick than a copyleft clause, but it is real — if you are bundling this into a commercial dictation app, read the file rather than assuming "Apache means rename it and ship."

Do not confuse this checkpoint with Fish Audio's S1-mini, a 0.5B distilled TTS model from a different lab. Same nickname, opposite direction of the speech stack. Fish Audio's commercial line is S2.1 Pro. Superwhisper's S1-mini does not speak.

Honest limits

• English only. v1. No multilingual claim, unlike Parakeet TDT v3's 25-language set.
• Not a chat model. It will not follow general instructions. The three control axes are the only steering.
• Dictation-length context. Keep passes under ~1,000 tokens; chunk longer meetings (Meetily-style hour-long transcripts need a splitter, not one forward pass).
• 94.8% is Superwhisper's number, greedy, on their 7,519-case mix of real ASR and synthetic stress sets. It is not an independent WER bake-off against a prompted 7B. Token accuracy on a normalizer is also not word error rate on audio.
• Hub parameter count is noisy. Unique parameters are 596M; the 0.8B sidebar number double-counts tied embeddings, same as stock Qwen3-0.6B.
• In-app vs weights. Superwhisper says try it in the app today. The Hugging Face repo is what you embed. Those are not automatically the same binary, the same control-line UX, or the same update cadence.

For a privacy-first local stack this still earns a slot: ASR stays local, cleanup stays local, nothing about the utterance needs a cloud rewrite pass. That is the same posture as keeping models on-device instead of defaulting to a hosted API — just applied to the unglamorous stage between "words" and "readable."

The takeaway

S1-mini is a specialist, and the X thread treated it like a general. Superwhisper open-weighted the cleanup head of a dictation app, not a new Parakeet. If you dictate or transcribe locally already, the useful move this week is to put the Q4 GGUF behind your existing ASR and measure whether semi-formal / prose / general beats your current regex-and-hope formatter. If you do not have an ASR yet, start with Parakeet or Whisper — then add this.

Related on explainx.ai:

• Meta AI Mac app — systemwide dictation (Aug 19) — cloud overlay vs S1-mini sitting after local ASR
• FluidVoice: local macOS dictation with Parakeet — S1-mini is the open-weights analogue of Fluid Intelligence, not a Parakeet swap
• Meetily: local Whisper/Parakeet meeting notes — where a 1,000-token chunker actually matters
• Hugging Face speech-to-speech voice agents — VAD → Parakeet → LLM → TTS; S1-mini fits between STT and the LLM
• What is llama.cpp? — how to serve the GGUF
• Run open-source models locally in OpenCode — Ollama / llama.cpp / LM Studio patterns
• LFM2.5-2.6B: on-device agent model — another small specialist that is not a chat generalist
• Mercury 2: real-time transcript cleanup at API speed — hosted alternative when 0.6B local is not enough
• Closed-source vs local open-source AI

Official: superwhisper/s1-mini on Hugging Face · GGUF builds

Model card figures (94.8% token accuracy, 7,519 cases, 462 MiB Q4, control-line behavior, license wording) reflect Superwhisper's v1 release as of August 19, 2026 and may change in later revisions.