Ming-3.0-asr-tiny vs Moonshine 250M: One Model Never Stops Listening, the Other Never Starts Until You Finish

There is a naming problem to clear up before anything else, because it changes what this comparison is. Moonshine publishes three checkpoints — Tiny at 34M, Small at 123M and Medium at 245M — and Moonshine 250M is the shorthand the community uses for the top of that line, the checkpoint whose repository name is moonshine-streaming-medium and whose safetensors index actually totals 265,898,112 parameters. No file anywhere in the Moonshine organisation is named 250M. That model is an English streaming recogniser with a sliding-window encoder and an autoregressive decoder, built for a laptop or a phone, released in January 2026 under MIT. Ming-3.0-asr-tiny is an 8.87-billion-parameter Chinese-and-English recogniser whose weights appeared on Hugging Face on 14 October 2026 without an announcement, built around a Whisper-shaped encoder and a 128-expert mixture-of-experts decoder, and designed to read a whole clip at once. They are not rivals in the same market. They are two different answers to the question of when a recogniser is allowed to speak. The checkpoint this piece calls Moonshine 250M is documented at the Moonshine Streaming Medium model card, where the safetensors index reports 265,898,112 parameters against the card's 245M label. The documented AI failures and agent incidents behind releases like this one are collected in the OrcaRouter AI Incident Archive where each entry carries its own sources, severity, confidence grade and disputed flag.

That question is the useful frame, and it produces a cleaner decision than an accuracy table would. Moonshine 250M emits words while the audio is still arriving, on about 0.1 to 1 TOPS. Ming-3.0-asr-tiny emits nothing until you hand it a complete file, and then it emits a transcript with no timestamps at all.

What each one is actually built to do

Moonshine's architecture is a deliberate inversion of the usual streaming compromise. The encoder is a sliding-window transformer with bounded local attention and no positional embeddings at all — the card calls it ergodic — windowed as (16, 4) in the first two and last two layers and (16, 0) in the intermediate ones, which yields about 80 milliseconds of lookahead. Positional information is injected by an adapter after the encoder, feeding a standard causal decoder with RoPE. The audio frontend runs at 50 Hz using simple time-domain operations rather than a mel spectrogram.

The decoder is autoregressive, and Moonshine says what that costs: full-output latency grows with transcript length even when time-to-first-token is low. That is the honest limitation of the design, and it is the one sentence to keep in mind when comparing streaming claims. Streaming means the first words appear quickly; it does not mean the last word appears proportionally quickly.

Ming does not stream, and its card states it: the bundled example does not accept streaming input. Long audio can be chunked through an argument against an 8,192-position context, but chunking a file is not the same as consuming a live feed, and the output format field in the config is set to plain. What Ming does instead is carry context. It accepts hotwords or the preceding dialogue turn as part of the transcription prompt, and it is evaluated across fifteen Chinese dialect test sets — Hunan, Minnan, Cantonese, Chuanyu, Shanghai, Anhui, Northeast, Henan, Hubei, Jiangsu, Hakka, Shaanxi, Shandong, Tianjin, Yunnan. Moonshine is English-only and has none of this.

The two parameter counts, and why they differ

A detail worth dwelling on, because it is the kind of thing that quietly breaks a comparison table: Moonshine's own card lists Medium at 245M parameters, 14 encoder and 14 decoder layers, a 768-dimension encoder and a 640-dimension decoder. The safetensors index in the same repository reports 265,898,112. The gap is about 21 million, roughly eight and a half percent, and it is not a rounding error — it is the difference between counting a backbone and counting everything that ships with it.

Ming has the same problem in a larger size. Its index reports 8,865,800,992 parameters; its charts label the model 8.6B-A2B, a shorthand for 8.6 billion total with about 2 billion active per token. The label is roughly 270 million below the index.

• Total parameters — Ming-3.0-asr-tiny 8.87B (index) versus Moonshine 250M 266M (index); vendor labels say 8.6B and 245M.

• Active per token — about 2B for Ming, since 8 of 128 experts route per step. All 266M for Moonshine, which is dense.

• Encoder — 32 layers, 1,280 dimensions, 20 heads, 128 mel bins, Whisper-shaped, versus a 14-layer ergodic sliding-window transformer at 768 dimensions over a 50 Hz frontend.

• Decoder — 24 layers, 128 experts, autoregressive; versus 14 layers, dense, autoregressive.

• Latency model — whole clip in, transcript out, no streaming; versus ~80 ms lookahead and a first token while audio is still arriving.

• Output — plain transcription text, no timestamps, no diarisation; versus transcription text from an autoregressive decoder that also has no timestamp path in the card.

• Languages — Chinese and English plus 15 Chinese dialect test sets; versus English only.

• Licence — MIT for both, with bundled Apache-2.0 headers retained in Ming's repository.

Accuracy, with the caveat that they were never tested on the same audio

Moonshine's card reports an average WER of 6.65 across eight English sets for Medium: 10.68 on AMI, 11.90 on Earnings-22, 9.46 on GigaSpeech, 2.08 on LibriSpeech test-clean, 5.00 on test-other, 2.58 on SPGISpeech, 2.99 on TED-LIUM and 8.54 on VoxPopuli. Trained on roughly 300,000 hours of speech.

Ming reports 3.99 average WER on its English public sets — LibriSpeech clean and other, Multilingual LibriSpeech, FLEURS English, Common Voice 15 English and VoxPopuli — and 3.55 average CER on its Chinese sets. Trained on an undisclosed amount of data.

The temptation is to put 3.99 next to 6.65 and declare Ming more accurate in English. Do not. Two of the five English sets differ, the aggregation differs, Moonshine's card does not publish a per-set breakdown that maps cleanly onto Ming's five, and neither vendor ran the other. On the one set both report — VoxPopuli — Ming does not publish a per-set English figure in its prose at all, only the average, so even that single overlap cannot be compared from the cards. Every number here is vendor-reported and unreproduced.

What can be said without a shared test set is structural. Moonshine is a 266-million-parameter dense model trained on 300,000 hours of English. Ming is an 8.87-billion-parameter mixture-of-experts model with roughly 2 billion active, trained on data it does not describe, evaluated on Chinese and English with a heavy dialect component. A model with seventeen times the active parameters and a language-model prior should be more accurate on hard English audio, and it would be surprising if it were not. That is an expectation from architecture, not a measurement.

Where the deployment realities diverge

Ming needs a Linux machine with a CUDA GPU, Python 3.12, PyTorch 2.11.0, torchaudio 2.11.0, Transformers 5.12.1, fla-core 0.5.2, and trust_remote_code=True to load its own modelling code. The weights are about 17.7 GB in BF16 across two shards. There is an SGLang serving path, pinned to a specific adapter commit, which is a signal that the vendor expects this to run behind an API rather than on a desk.

Moonshine 250M targets sub-1 GB of memory and roughly 0.1 to 1 TOPS. It runs through the Moonshine Voice framework for edge devices and through Transformers, and the card says plainly that the Transformers path does not yet implement fully efficient streaming — it leans on flash-attention's sliding-window support. If you want the streaming behaviour the architecture promises, the framework path is the one that delivers it.

The repository is where the checkpoint line is actually visible: twenty-four tags across a Tiny, Small and Medium family, plus the framework the card tells you to use if you want real streaming. That is a maintenance story Ming does not yet have, and it is the practical half of the choice.

That is the whole comparison in two sentences: one model is designed to be forgotten about inside a device, and the other is designed to be served from a GPU with a hotword list attached.

What a Chinese-first team should actually do

If your product is a live caption or a voice command in English, Moonshine 250M is doing the job Ming cannot do at all, and the accuracy gap — whatever it turns out to be — is unlikely to matter more than the fact that Ming cannot consume a live stream. Streaming is not a feature you add later to an architecture that reads whole clips; it is a property of the encoder.

If your product is Chinese speech, or a regional dialect, or a batch pipeline where transcripts are produced after the fact and names matter, Ming is the only one of the two that addresses the problem, and it is five days old with a download count in the tens. The honest recommendation is a bake-off on your own audio, scored on named-entity recall rather than character error rate, because that is the axis Ming was built for.

For teams running that bake-off, the operational problem is not the model, it is the plumbing: two stacks, two dependency sets, two sets of credentials, and no way to compare them on the same traffic without building a harness. OrcaRouter does not host either model — Ming-3.0-asr-tiny and Moonshine 250M are self-hosted open weights — but it does put 200-plus hosted models behind one API key with automatic failover, so the hosted baseline you score against can sit next to your self-hosted candidate without a second contract. Provider list prices pass through at 0% markup, which is the number that matters when you are comparing cost per hour of audio rather than cost per token.

The open question worth watching

Ming's card says hotwords are hints, not guarantees, and that output is text without word-level timestamps or speaker diarisation. Moonshine's card says its decoder can hallucinate words and repeat phrases on short or noisy segments. Both are honest about failure modes, which is more than most cards manage, and both are describing the same underlying compromise from opposite ends: an autoregressive decoder that produces fluent text will sometimes produce fluent text that was not said.

What would settle this comparison is not a benchmark but a use case. Run both on the same twenty minutes of your own audio — half live, half batch, half English, half not — and the decision stops being about parameter counts entirely. Until then, the correct description of the matchup is that one model is built to listen continuously and the other is built to read carefully, and the name on the smaller one is a marketing shorthand for a checkpoint that is, in fact, 266 million parameters.