betaFeedback

WorksComputer Science

Decode Early, Verify Late: Streaming Offline Speech Recognizers Without Accuracy Loss

Abstract

Voice agents need accurate transcripts soon after a user stops speaking. We propose Decode Early, Verify Late (DEVL), a training-free framework for streaming inference with offline ASR models. The server keeps partial transcripts as drafts and verifies the latest against the complete audio in one forward pass at turn end. Under stated input and decoding conditions, the final equals the model's greedy offline output in exact arithmetic. We adapt DEVL to four model families. In our five-recognizer comparison, 95-100% of final transcripts are byte-identical to the offline transcripts, WER stays within 0.13 points of offline, and single-stream time to final falls 1.5-7.3x. Serving Qwen3-ASR-1.7B on one A100, DEVL returns finals a median 22-26 ms after turn end at up to 64 streams, 2.7-3.9x sooner than the official streaming mode. It is the only system we tested that meets a 100 ms p99 target, up to 80 streams on Pipecat-STT and 64 on WildASR.

Introduction

A streaming recognizer shows partials during speech and returns a final transcript when the turn ends, at the commit. The time to final segment (TTFS), from commit to final, adds to the delay before a voice agent answers. A GPU’s capacity is the number of streams it serves within a TTFS target.

The most accurate open-weight recognizers are offline models, which decode a complete utterance at once. On the Open ASR Leaderboard [19] (10 November 2026), the top three open-weight entries are all offline: a Qwen3-ASR fine-tune, NVIDIA-Nemotron-3.5-Transcribe-30B-A4B [11] and Qwen3-ASR-1.7B [18]. The best streaming entry ranks 38th of 64.

Existing streaming options cost accuracy or time. Qwen3-ASR’s toolkit fixes earlier output as a prefix [14]; NVIDIA Nemotron and Microsoft VibeVoice offer separate streaming models [10, 21]; Whisper-Streaming keeps text that consecutive hypotheses agree on [7, 8]. Each has higher WER than offline decoding in our engine (Table 2, with a decoding-settings caveat for Whisper). vLLM’s realtime mode for Qwen3-ASR restates earlier segments and scores 47.7% (Pipecat-STT) and 54.2% (WildASR) WER (§ 3). Alternatively, vLLM [4] and SGLang-Omni [17] decode the complete utterance at the commit, placing the whole decode between the user’s last word and the agent’s reply.

Table 2: Accuracy and TTFS of five recognizers. Identical: byte-identical final transcript text (§ 3.1). TTFS: median at one stream, drafts off → on. Qwen3-ASR uses client timing with epochs off; its WER and identical share come from the 64-stream run. Other models use server timing. Streaming: each model’s usual option; {sup}§Whisper-Streaming {citep}[8] on another backend, with most of its gap due to default decoding settings; {sup}‡Microsoft’s separate VibeVoice-ASR-Streaming-7B [21]; {sup}†NVIDIA’s separate nemotron-3.5-asr-streaming-0.6b {citep}[10]`. Samples in Section A.

modeldataofflinestreamingDEVLidenticaldrafts off → on
Qwen3-ASR-1.7BPipecat-STT1.781.941.7798.0%115 → 24
WildASR4.755.144.6598.5%78 → 25
Whisper large-v3-turboPipecat-STT3.4510.72{sup}§`3.4599.7%58 → 32
WildASR5.7011.76{sup}§`5.70100%48 → 32
Whisper large-v3Pipecat-STT3.586.12{sup}§`3.5899.7%223 → 58
WildASR5.055.54{sup}§`5.0599.7%159 → 59
VibeVoice-ASRPipecat-STT2.624.08{sup}‡`2.6595.4%888 → 121
WildASR12.4416.92{sup}‡`12.3195.5%701 → 135
NVIDIA-Nemotron-3.5-Transcribe-30B-A4BPipecat-STT1.745.62{sup}†`1.7295.0%427 → 176
WildASR4.6811.51{sup}†`4.6395.1%308 → 180

Table 2. Accuracy and TTFS of five recognizers. Identical: byte-identical final transcript text (§ 3.1). TTFS: median at one stream, drafts off → on. Qwen3-ASR uses client timing with epochs off; its WER and identical share come from the 64-stream run. Other models use server timing. Streaming: each model’s usual option; {sup}§Whisper-Streaming {citep}[8] on another backend, with most of its gap due to default decoding settings; {sup}‡Microsoft’s separate VibeVoice-ASR-Streaming-7B [21]; {sup}†NVIDIA’s separate nemotron-3.5-asr-streaming-0.6b {citep}[10]`. Samples in Section A.

Decode Early, Verify Late (DEVL) reuses the partials a streaming server already computes. With Qwen3-ASR, the last partial matches the first 88% of the final’s words in the median on Pipecat-STT [13] and 82% on WildASR [20]. DEVL keeps each partial as a draft. At the commit, one forward pass checks it against the complete audio, as in speculative decoding [5], and decoding resumes after the longest correct prefix.

We state conditions for exact greedy offline finals (§ 2), adapt DEVL to four model families (Table 1), and evaluate a scheduler that prioritizes finals over drafts on five recognizers, two datasets and 1–128 concurrent streams (§ 3).

modelencoder seescached in speechcommit workrollback
Qwen3-ASRfixed windowsencoder blocks, decoder KVprefill tail and drafttruncate KV
Whisperwhole clip–encode all; prefill and draftoverwrite KV
VibeVoice-ASRcausal chunksencoder outputencode tail; prefill and draftoverwrite KV
Nemotronwhole clip–encode all; prefill and draftreplay state

Table 1. How DEVL adapts to each model family. Cached in speech: work reused at the commit. Commit work: what is left when a draft is available. Nemotron replays its Mamba-2 state. Only the Qwen3-ASR engine cuts long utterances into epochs.

Developed in summer 2026, DEVL powers our hosted Qwen3-ASR service, which ranked first in TTFS (44 ms median) and second in WER (3.6%) on Coval’s speech-to-text benchmark in September 2026 [9].

Method

An offline recognizer encodes audio xx into embeddings that form part of the text decoder’s prompt. The decoder prefills the prompt, caches its state, then generates tokens greedily until end-of-sequence. We write this output as G(x)\mathcal{G}(x).

DEVL targets G(x)\mathcal{G}(x) with the server’s own weights and kernels. It requires greedy decoding, a deterministic front end and decoder state that can be restored to an accepted prefix. Whenever a draft is checked, the audio representations, prompt, token positions and retained decoder state must equal those of an offline pass over the same audio. Cached representations are recomputed if new audio changes them. Four design choices maintain this invariant for Qwen3-ASR (Figure 1 and Algorithm 1).

One stream in DEVL

Figure 1. One stream in DEVL. Audio is encoded and prefilled into the KV cache as it arrives. Checkpoints decode the audio so far and keep each result as a draft d(k)d^{(k)}. At the commit, the server prefills only the tail, verifies the last draft in the same pass, and decodes only after its longest correct prefix.

First, DEVL encodes fixed audio blocks counted from the stream’s start, independent of the client’s chunk boundaries. Each valid block is prefilled into the KV cache once. If input normalization changes, all completed blocks and their decoder state are rebuilt. At the commit, only the tail after the last cached block remains.

Second, checkpoints produce partials during speech. A checkpoint copies the stream’s KV cache, prefills uncached audio and the prompt suffix, then checks the previous draft by the same rule as the final. It decodes beyond the accepted prefix, sends the result as a partial and keeps it as the next draft, recording the audio it saw.

Third, DEVL checks the latest draft in the same pass that prefills the audio tail and prompt suffix. Up to the first mismatch, the draft equals greedy decoding [5]. The server rolls back to that prefix and continues decoding. It can realign the remaining draft after a correction and verify it again. A completed checkpoint that saw all the audio can be promoted directly to the final. If no draft is usable, the server decodes normally.

Fourth, the scheduler runs pending finals before checkpoints. A checkpoint delays a final by at most the GPU step already running; finals can still queue behind other finals. Checkpoints use remaining GPU time, with at most four streams active except when epoch cuts require more. The engine uses a paged KV cache [4] and CUDA graphs.

Under these conditions, finals equal G(x)\mathcal{G}(x) in exact arithmetic (proof in Section A). Our Qwen3-ASR engine also cuts utterances longer than 10 s into epochs at sentence ends to shorten the final decode. Epoch-cut finals are outside this guarantee.

Other architectures. Table 1 adapts these choices to Whisper [15], VibeVoice-ASR [12] and NVIDIA-Nemotron-3.5-Transcribe [11]. Windowed or causal encoders can reuse audio representations; whole-clip encoders re-encode all audio at the commit. For VibeVoice-ASR, we remove input gain and use the mean acoustic latent to make the front end deterministic. Nemotron restores its recurrent Mamba-2 state by replaying accepted inputs, as in ReplaySSM [6].

Evaluating Streaming Recognizers for Voice Agents

We measure TTFS under load and compare final transcripts with each model’s offline decode in our engine.

Data and Benchmarks

Pipecat-STT. The 897 voice-agent turns of Pipecat’s stt-benchmark-data [13], as packaged in Coval’s stt-v3 set [2]. Its reference transcripts were generated by Gemini, not by humans.

WildASR. Coval’s seven WildASR sets [2, 20], with 2,549 English clips. Six sets play FLEURS sentences under different recording conditions, and one holds accented speech.

Load and metrics. A closed loop keeps CC streams open, each starting its next utterance when the previous final arrives. Streams send 100 ms chunks in real time and commit with the last chunk. TTFS is measured at the client, with 95% bootstrap intervals. Capacity is the largest measured load meeting the target at that and every lower load. Identical compares final transcript text byte for byte with the offline transcript. For VibeVoice-ASR, this is the joined JSON Content text, excluding timestamps and speaker metadata.

Baselines

Our engine serves Qwen3-ASR-1.7B on one A100-SXM4-40GB. The no-drafts server is the same engine with checkpoints and epochs off. The offline reference decodes each complete utterance alone on it. We compare against Qwen3-ASR’s toolkit (qwen-asr 0.0.6) [14] in its official streaming mode. Every 2 s, it re-decodes all audio so far, with its earlier output as a fixed prefix. We also compare against SGLang-Omni 0.2.0 and vLLM 0.33.0, which transcribe the complete utterance at the commit. We exclude vLLM 0.33.0’s realtime mode, which restates earlier 5 s segments in 48% (Pipecat-STT) and 58% (WildASR) of utterances; vLLM-Omni does not serve Qwen3-ASR as a standalone recognizer.

We also run Whisper large-v3-turbo and large-v3, VibeVoice-ASR and NVIDIA-Nemotron-3.5-Transcribe-30B-A4B [11]. Each is compared with its own offline decode and with its usual streaming option.

Results

Accuracy across five recognizers

In the five-recognizer comparison (Table 2), DEVL’s WER is within 0.13 points of offline decoding, 95–100% of final transcripts are byte-identical, and single-stream finals arrive 1.5–7.3× sooner. Whisper-Streaming’s accuracy gap mostly comes from its default decoding settings (Section A). Where we recorded logits for DEVL’s differing fins, the first divergence was at a near-tie between the top two tokens. Even without drafts, batching changes up to 1.9% of Qwen3-ASR’s finals at 128 streams (Section A).

Qwen3-ASR under load

Up to 64 streams, DEVL returns finals a median 22–26 ms after the commit on both datasets (Figure 2). That is 2.72.7–3.9×3.9\times sooner than the official streaming mode, which decodes only past its fixed prefix and pays the accuracy cost in Table 2. It is 3.23.2–5.0×5.0\times sooner than the no-drafts server, and 4.14.1–8.3×8.3\times sooner than SGLang-Omni and vLLM. Only DEVL meets a 100 ms p99 target: up to 80 streams on Pipecat-STT and 64 on WildASR. Every other system misses it even at one stream (Table 4). At a 300 ms p99 target, DEVL, the no-drafts server and SGLang-Omni all hold up to 128 streams. No system had a failed request.

Qwen3-ASR TTFS under load, with Pipecat-STT and WildASR panels

Figure 2. Qwen3-ASR TTFS under load, one A100. Median TTFS with 95% intervals against concurrent streams, log scale (lower is better). SGLang-Omni and vLLM transcribe the complete utterance at the commit.

Table 4: Qwen3-ASR streams per A100 at a p99 TTFS target. DEVL and no drafts ran at the loads in Table 3; other systems at 1, 8, 32, 64 and 128 streams. Capacity is the largest tested load meeting the target at that and every lower load; “–” means not met even at one stream.

Pipecat-STTWildASR
p99 TTFS target100 ms200 ms300 ms100 ms200 ms300 ms
no drafts–1128–32128
DEVL80801286496128
official streaming–3264–3264
SGLang-Omni–1128–1128
vLLM––32––64

Table 4.

The no-drafts server also turns epochs off, so this gap mixes two effects. On utterances up to 10 s, which are never cut into epochs, DEVL’s median TTFS at 1 to 64 streams is 20–26 ms, against 58–95 ms without drafts. Drafts help only while checkpoints finish before the commit. At 64 streams, at least 98% of finals are checked against a draft, but at 128 streams only 21–29% are. Letting 16 or 32 streams run checkpoints at once keeps 95% or more checked, and on Pipecat-STT cuts the median TTFS at 128 streams from 138.5 ms to 38.2 and 32.6 ms.

Other recognizers under load

We also batched the other recognizers with finals before checkpoints and the same client, using client-side timing and the GPUs listed in Table 5. Only Whisper large-v3-turbo meets a 100 ms p99 target: up to 80 streams on Pipecat-STT and 32 on WildASR, against 32 and 8 without drafts. The other three miss it even at one stream.

Table 5: Capacity of the other recognizers. Cells are streams served with no drafts → DEVL, or one value when equal; “–” as in Table 4; loads as for DEVL there, with 16 and 48 also tested for VibeVoice-ASR. GPUs: A100-SXM4-40GB (Whisper), A100-SXM4-80GB (VibeVoice-ASR), RTX PRO 6000 96 GB (Nemotron).

Pipecat-STTWildASR
p99 TTFS target100 ms300 ms1000 ms100 ms300 ms1000 ms
Whisper large-v3-turbo32→8032 \to801281288→328 \to32128128
Whisper large-v3–→64\to64128–8→328 \to32128
VibeVoice-ASR––→8\to8––1
Nemotron-3.5-Transcribe–→8\to88→328 \to32–→1\to18→328 \to32

Table 5.

Once the GPU is busy with finals, checkpoints rarely finish in time, and drafts stop helping. From 32 streams, VibeVoice-ASR’s medians with and without drafts are within 8% of each other. From 64 streams, Nemotron’s median with drafts is up to 16% higher. Without drafts, batching alone changes up to 6.1% of finals. With drafts, 93.5–100% of finals stay identical at every load, and WER stays within 0.3 points of the no-drafts arm. The exception is VibeVoice-ASR runs where only one arm drew a clip on which the model loops (Section A).

Endpointing

Our client commits with the last chunk of speech. A deployed client instead commits after a silence timeout, so we appended 300 or 600 ms of silence at 1, 32 and 64 streams. Measured from the end of speech, DEVL’s median stays 59–108 ms below the no-drafts server’s, at equal WER. At 32 and 64 streams, 96.7–98.1% of its finals are identical to offline decodes of the padded audio.

Related Work

Streaming ASR. Local agreement [7, 8] keeps the text that consecutive hypotheses agree on, and Qwen3-ASR’s toolkit fixes a prefix [14]. None of them checks earlier output against the model on the complete audio. Two-pass systems [16] re-decode a streamed first pass with full context, but do not reuse it to reach an exact final sooner.

Drafts. Speculative decoding preserves the target model’s output rule [5]; SpecASR uses a separate draft recognizer to accelerate offline ASR [22]. SSBD reuses previous translations as drafts for growing text input, with biased verification and a zero-bias variant [23]. Speculative Listening drafts under assumed silence and verifies against arriving audio in already chunk-interleaved full-duplex speech models [1]. DEVL addresses streaming conversion of offline ASR: the audio, prompt and state invariants for full-utterance greedy finals, adaptations across four model families, and serving measurements under load.

Limitations and Future Work

Our benchmarks are English, and Pipecat-STT’s references are machine-generated. Batch-dependent GPU rounding changes some finals; batch-invariant kernels [3] could reduce this. DEVL requires the model properties in § 2. Checkpoints consume GPU time and help slower models mainly at low load. The scheduler favors finals; improving partial latency remains future work.

Conclusion

DEVL turns partial transcripts into verified drafts for offline ASR. Under the stated invariants, finals equal greedy offline output in exact arithmetic. The five-recognizer comparison retains 95–100% byte-identical transcripts, and Qwen3-ASR meets a 100 ms p99 TTFS target at 64–80 concurrent streams on one A100.

Acknowledgments. AI tools assisted with writing, literature search, implementation, and research analysis.

Exactness and settings

Exactness on Qwen3-ASR. Table 3 separates batching effects from drafts: without drafts, all finals match at one and eight streams, falling to 98.1–98.8% at 128 streams. Drafts retain 96.8–99.3% across loads. At one stream, epochs cut 42% of Pipecat-STT and 11% of WildASR utterances; 97.9% and 100% of those finals still match, respectively.

Table 3: Qwen3-ASR exactness by load. Finals byte-identical to the offline reference (%), and WER (%) over each run’s requests. N: no drafts. D: DEVL.

CCPipecat-STTWildASR
identicalWERidenticalWER
NDNDNDND
1100.097.31.971.89100.099.33.593.58
8100.096.81.801.77100.098.53.924.00
3299.597.61.811.8199.898.54.544.56
6499.398.01.771.7799.598.54.654.65
8099.298.21.781.7899.298.54.684.72
9698.898.11.831.8199.198.74.794.81
11298.598.41.811.8399.098.54.794.78
12898.198.31.771.7798.898.84.814.82

Table 3.

Qwen3-ASR baselines. Cross-request caches are disabled because the client replays utterances. SGLang-Omni and vLLM score 1.75% and 1.77% WER on Pipecat-STT; both score 4.70% on WildASR.

Other models. Table 2 uses single-stream cloud A100 runs: 300 utterances per dataset for Whisper, all Pipecat-STT and 1,000 WildASR clips for VibeVoice-ASR and Nemotron. One WildASR clip makes every VibeVoice-ASR arm loop to its output limit, including offline, and is excluded. Whisper-Streaming uses faster-whisper defaults: whole-utterance decoding with those settings is within 2 WER points of its streaming result, while greedy decoding on that backend is within 0.2 points of our engine. Thus most of its gap comes from decoding settings. Batched runs use each engine’s own offline reference on the same GPU and draw from all 2,549 WildASR clips. VibeVoice-ASR loops on two clips: excluding them gives 11.3–12.8% WER across runs; including them raises it to as much as 20.2%.

Algorithm 1 DEVL for one stream (Qwen3-ASR). KK: the stream’s KV cache. dd: the latest draft. Continuation processes the last returned token unless it is end-of-sequence (EOS).

initialize: K←K \leftarrow prefill of the prompt prefix; d←∅d \leftarrow\emptyset

  1. function Check(KK, new input, dd) ▹\triangleright one prefill pass per check

  2. k←∣d∣k \leftarrow|d|; prefill the new input and d1:max⁡(k−1,0)d_{1:\max(k-1,0)} on top of KK

  3. let γ1:max⁡(k,1)\gamma_{1:\max(k,1)} be the next-token argmaxes at the draft positions

  4. a←max⁡{r∈{0,…,k}:dj=γj for all j≤r}a \leftarrow\max\{r \in\{0,\ldots,k\}:d_j=\gamma_j\text{ for all }j\le r\}

  5. p←dp \leftarrow d if a=k>0a=k>0, otherwise d1:aγa+1d_{1:a}\gamma_{a+1} ▹\triangleright empty draft uses γ1\gamma_1

  6. truncate KK after p1:∣p∣−1p_{1:|p|-1} ▹\triangleright keep the last token as the decode seed

  7. if a<ka<k and pp does not end in EOS, realign the rest of dd after pp and extend pp by the same check, at most three repair rounds

  8. return pp ▹\triangleright each repair preserves the cache convention above

on new audio:

  1. if the input normalization changed then discard cached audio; reset KK to the prompt prefix

  2. encode and prefill every complete block not currently cached ▹\triangleright rebuild invalidated blocks

  3. if a checkpoint is due and the scheduler admits it then

  4. p←p \leftarrow Check(copy of KK, uncached audio and prompt suffix, dd)

  5. greedily continue pp; d←d \leftarrow the result; send dd as a partial; record the audio it saw

  6. if the epoch exceeds 10 s and dd ends at a stable sentence end then ▹\triangleright epoch

  7. emit that text; start a new epoch from shortly before the cut

on commit:

  1. if the last checkpoint saw all the audio and ended with end-of-sequence then return dd ▹\triangleright promotion

  2. p←p \leftarrow Check(KK, tail and prompt suffix, dd); decode greedily after pp until end-of-sequence

  3. return the result ▹\triangleright residual decoding

Correctness sketch. Consider an utterance without epoch cuts, in exact arithmetic, with audio xx and greedy output y⋆=G(x)y^\star=G(x). Inputs. A block is featurized only after its analysis windows are complete, with frames indexed from the stream’s start. Rebuilding cached blocks when normalization changes makes their features equal to the offline features F(x)F(x). Independent encoder windows and identical absolute token positions then make the cached encoder outputs and KV state equal to an offline prefill. Verification. If draft tokens before position ii match the greedy output, the input at ii is the offline prompt followed by y<i⋆y^\star_{<i}, so its argmax γi=yi⋆\gamma_i=y^\star_i. By induction, the accepted prefix and first correction form a prefix of y⋆y^\star. If all k>0k>0 draft tokens match, the draft itself is such a prefix; no γk+1\gamma_{k+1} is needed. An empty draft yields γ1=y1⋆\gamma_1=y^\star_1. Truncating the cache before the last returned token and processing that token resumes the offline decode; EOS ends it. Repair rounds use the same test. Promotion. A completed checkpoint with the final sample count and normalization has the same offline prompt, so its EOS-terminated output is G(x)G(x). Other models. Whisper and Nemotron recompute the complete audio at the commit. Nemotron replays accepted tokens to restore the offline recurrent state; VibeVoice-ASR uses the deterministic front end described in § 2.

References

  1. [1]Y. Bian, Y. Zhang, Y. Wang, L. Zhang, R. He, Z. Wang, et al. Decode before you hear: Speculative listening for chunk-interleaved full-duplex speech language models, 2026. arXiv:2611.06982.arxiv.org/abs/2611.06982
  2. [2]Coval. Coval benchmarks. https://github.com/coval-ai/benchmarks, 2026. stt-v3 and WildASR manifests v1.0.0 at commit db1e3d4. Accessed November 2026.
  3. [3]H. He and Thinking Machines Lab. Defeating nondeterminism in LLM inference. https://thinkingmachines.ai/blog/defeating-nondeterminism-in-llm-inference/, Sept. 2025. Thinking Machines Lab: Connectionism.DOI
  4. [4]W. Kwon, Z. Li, S. Zhuang, Y. Sheng, L. Zheng, C. H. Yu, et al. Efficient memory management for large language model serving with PagedAttention. In Proc. 29th Symposium on Operating Systems Principles (SOSP), pages 611–626. ACM, 2023.arxiv.org/abs/2309.06180
  5. [5]Y. Leviathan, M. Kalman, and Y. Matias. Fast inference from transformers via speculative decoding. In Proc. International Conference on Machine Learning (ICML), volume 202 of Proceedings of Machine Learning Research, pages 19274–19286. PMLR, 2023.arxiv.org/abs/2211.17192
  6. [6]Z.-W. Liou, H. Nover, A. Naik, A. Skliar, I. Shovkun, I. Shahaf, and T. Dao. ReplaySSM: Cache SSM inputs, not state, 2026. arXiv:2610.13778.arxiv.org/abs/2610.13778
  7. [7]D. Liu, G. Spanakis, and J. Niehues. Low-latency sequence-to-sequence speech recognition and translation by partial hypothesis selection. In Proc. Interspeech, pages 3620–3624, 2020.arxiv.org/abs/2005.11185
  8. [8]D. Macháček, R. Dabre, and O. Bojar. Turning Whisper into real-time transcription system. In Proc. 13th International Joint Conference on Natural Language Processing and the 3rd Conference of the Asia-Pacific Chapter of the Association for Computational Linguistics: System Demonstrations (IJCNLP-AACL), pages 17–24, Bali, Indonesia, 2023. Association for Computational Linguistics.
  9. [9]Nari Labs. Nari labs leads coval’s voice ai benchmarks. https://narilabs.com/blog/nari-labs-leads-coval-voice-ai-benchmarks/, 2026. Coval speech-to-text benchmark, 1-day view on 14 September 2026. Accessed November 2026.
  10. [10]NVIDIA. NVIDIA- Nemotron-3.5-ASR-streaming-0.6b. https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b, 2026. Model card, revision ea30d66. Accessed November 2026.
  11. [11]NVIDIA. NVIDIA Nemotron-3.5-Transcribe-30B-A4B. https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B, 2026. Model card, revision c17676. Accessed November 2026.
  12. [12]Z. Peng, J. Yu, Y. Chang, Z. Wang, L. Dong, Y. Hao, et al. VibeVoice-ASR technical report, 2026. arXiv:2601.18184.arxiv.org/abs/2601.18184
  13. [13]Pipecat. stt-benchmark-data: Speech-to-text benchmark data. https://huggingface.co/datasets/pipecat-ai/stt-benchmark-data, 2026. Hugging Face dataset, revision ea9d721, CC-BY-4.0. Accessed November 2026.
  14. [14]Qwen Team. Qwen3-ASR toolkit (qwen-asr 0.0.6). https://github.com/QwenLM/Qwen3-ASR, 2026. PyPI package qwen-asr 0.0.6. Accessed November 2026.
  15. [15]A. Radford, J. W. Kim, T. Xu, G. Brockman, C. McLeavey, and I. Sutskever. Robust speech recognition via large-scale weak supervision. In Proc. International Conference on Machine Learning (ICML), volume 202 of Proceedings of Machine Learning Research, pages 28492–28518. PMLR, 2023.arxiv.org/abs/2212.04356
  16. [16]T. N. Sainath, R. Pang, D. Rybach, Y. He, R. Prabhavalkar, W. Li, et al. Two-pass end-to-end speech recognition. In Proc. Interspeech, pages 2773–2777, 2019.arxiv.org/abs/1908.10992
  17. [17]sgl-project. SGLang-Omni: High-performance multi-stage pipeline framework for omni models. https://github.com/sgl-project/sglang-omni, 2026. GitHub repository. Accessed November 2026.
  18. [18]X. Shi, X. Wang, Z. Guo, Y. Wang, P. Zhang, X. Zhang, et al. Qwen3-ASR technical report, 2026. arXiv:2601.21337.arxiv.org/abs/2601.21337
  19. [19]V. Srivastav, S. Zheng, E. Bezzam, E. L. Bihan, N. R. Koluguri, P. Zelasko, S. Majumdar, A. Moumen, and S. Gandhi. Open ASR leaderboard: Towards reproducible and transparent multilingual and long-form speech recognition evaluation, 2025. arXiv:2510.06961. Leaderboard at https://huggingface.co/spaces/hf-audio/open_asr_leaderboard, version 1.15.1, accessed November 2026.arxiv.org/abs/2510.06961
  20. [20]G. Tay, W. Ma, J. Lee, Y. Tang, D. Lee, W. Yin, et al. Back to basics: Revisiting ASR in the age of voice agents, 2026. Introduces the WildASR benchmark. arXiv:2603.25727.arxiv.org/abs/2603.25727
  21. [21]Y. Tu, Z. Peng, J. Yu, L. Dong, S. Xu, Y. Chang, et al. VibeVoice-ASR-Streaming technical report, 2026. arXiv:2609.020812.
  22. [22]L. Wei, S. Zhong, S. Xu, R. Wang, R. Huang, and M. Li. SpecASR: Accelerating LLM-based automatic speech recognition via speculative decoding. In Proc. 62nd ACM/IEEE Design Automation Conference (DAC), pages 1–7, 2025.
  23. [23]L. Zeng, H. Deng, K. Shu, and S. Wang. Self-speculative biased decoding for faster re-translation, 2025. arXiv:2509.21740.arxiv.org/abs/2509.21740

Paper details

vlnc:W_jsqv2hr6
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
  • Computer Science

AI tools

View statement
Looking for related papers…
Contents