Underdog Bark 3.0 Pro vs Qwen3-ASR-1.7B: close on errors, a quarter of the size, runs on a CPU

Can a speech-to-text model a quarter the size of Qwen3-ASR-1.7B keep up on the same recordings? On 40 English clips from the standard benchmark sets, it came out close, slightly ahead. Underdog Bark 3.0 Pro, a 1.25 GB open model from Conway Research, got 6.28% of the words wrong. Qwen3-ASR-1.7B, a 4.7 GB model, got 7.03% wrong on the same audio, on the same RTX 3090. Most of the gap comes from one habit: Bark keeps the fillers and repeats people say, and Qwen drops many of them. Bark turned five minutes of speech into text in under three seconds of GPU work, 4.5 seconds counting the trip over the network. Four processor threads transcribe one recording faster than it plays. A GPU needs about 2 GB of memory once long audio is cut into pieces.

Same clip, same card. Bark keeps the "you know" and the repeats the reference keeps, and Qwen's cleaner text loses points for it.

A 1.25 GB model that ties for the best open score, by its own count

The claim that made us look is on the model's Hugging Face page. Bark scores a 4.29% average word error rate on the seven English test sets of the Open ASR Leaderboard, a public speech-to-text ranking. Word error rate is the share of words a model gets wrong, so lower is better. The page calls it the lowest of any open model. The lead is 4.286 against 4.291 for Hojo-ASR-V1, a tie with a model about ten times its size. The same table puts Qwen3-ASR-1.7B at 4.43% and OpenAI's Whisper large-v3 at 6.04%.

That score is self-reported. The page says the Bark rows use the leaderboard's scoring code but "are not on the leaderboard yet". The size gap needs no trust: 1,254 MB on disk against 4,699 MB for Qwen3-ASR-1.7B, a little over a quarter.

NVIDIA trained the base model, Parakeet TDT 0.6B v3, a speech model for 25 European languages released in August 2025. Moondream then made an improved version of it. Conway Research then retrained and shrank it into Bark, and published it on Hugging Face on 15 October. The Underdog team wrote the release post, which also lists three smaller siblings, down to 163 MB. The hf-audio team maintains the leaderboard and publishes the test audio we used. We spotted Bark in the AI Search news video of 25 October. The presenter said the Pro "should still be able to fit on most consumer GPUs". Our part was packaging Bark for deployment, putting it next to Qwen3-ASR on one card and counting the errors.

All three models in the chain use the same license, CC-BY-4.0. It allows commercial use, as long as you credit NVIDIA, Moondream and Conway Research.

The test: 40 clips compare the two models, they do not rerun the card's numbers

The model's page scores four of the sets after fixing errors in their answer text. We used the original versions, so our absolute numbers are not comparable with the page's table. Only the comparison between the two models is.

We drew eight clips at random from each of five sets in the leaderboard's own test data:

AMI: office meetings.
Earnings-22: company earnings calls.
GigaSpeech: podcasts and YouTube.
VoxPopuli: European Parliament speeches.
LibriSpeech test-other: audiobooks.

Each clip runs 4 to 20 seconds, almost six minutes and 924 words in all. We also stitched 33 more earnings-call segments into one five-minute file to test long audio.

Both models ran on the same RTX 3090 24 GB, one request at a time. We scored both the same way, with the scoring rules OpenAI wrote for Whisper: they ignore case, punctuation and "uh" or "um", so only real word differences count. The test ran on our cloud through a local test build of InferenceKey, not the hosted service.

Results: 6.28% against 7.03%, and the gap is mostly fillers like "you know"

Bark got 6.28% of the words wrong across the 40 clips, and Qwen3-ASR-1.7B 7.03%. Set by set, it is a split decision:

Set (8 clips each)	Bark 3.0 Pro	Qwen3-ASR-1.7B
Meetings (AMI)	11.54%	16.92%
Earnings calls (Earnings-22)	8.15%	10.87%
Podcasts and YouTube (GigaSpeech)	3.54%	4.04%
Parliament speeches (VoxPopuli)	8.04%	5.53%
Audiobooks (LibriSpeech test-other)	2.35%	1.88%
All 40 clips, 924 words	6.28%	7.03%

924 words is a small sample. A couple of words move a set's number, so read the total as "close, with Bark ahead", not as a ranking.

To see where the gap comes from, you need one idea: a verbatim transcript against a clean one. A verbatim transcript writes what was said, false starts and fillers included. A clean one writes what the speaker meant. Think of the live bootleg, coughs and all, against the studio cut. The leaderboard's answer keys, written by people, are verbatim. So is Bark, on purpose: "Bark 3.0 writes what was said, fillers included. It does not clean speech up," its authors write. Qwen3-ASR leans clean.

That explains most of the difference. Qwen left out 29 words that the answer keys contain, Bark 11. Most of Qwen's were fillers and repeats: "you know", "on, on", "how, how". On words heard wrong, Qwen was slightly ahead (28 against 32), so Bark's lead is about keeping what was said, not about hearing better. Bark loses points the other way. It writes stutters as heard, "h-how" and "w- where", and those count as errors too.

The earnings clip in the image above shows both habits in nine seconds. Bark scored 14.3% on it, Qwen 20.0%. Here is Bark:

Can you, uh, you know, just perhaps give us an update on, on how things have progressed there and, um, you know, h-how we're tracking relative to perhaps w- where you, where you were last quarter? Thank you.

And here is Qwen3-ASR:

Can you just perhaps give us an update on how things have progressed there, and you know how we're tracking relative to perhaps where you where you were last quarter? Thank you.

Bark's lead is largest on meetings and earnings calls, where the answer keys keep many fillers and repeats that Qwen drops. We did not find out why Qwen does better on parliament speeches and audiobooks.

Five minutes of audio in under three seconds of GPU work, in one piece

Bark is fast enough that the network is the slow part. The 40 clips took under five seconds of GPU work, about 0.12 seconds each. Counting the trip over the network, a typical clip came back in half a second. For Qwen3-ASR, a typical clip took 0.73 seconds. Qwen3-ASR ran on different serving software, so this compares setups as much as models.

The five-minute file took 2.8 seconds of GPU work in a single request. Counting the upload and the answer, it took 4.5 seconds. Bark returned the whole transcript, 715 words. We could not score it cleanly: the answer text we stitched together has gaps where the pieces meet (figure in the appendix).

Qwen3-ASR returned 212 words and stopped. We did not look into why.

Where it falls short: English only, verbatim, no timestamps

English only. Its base model handles 25 European languages. Bark does not.
Verbatim by design. If you want clean text, you need a cleanup step. The authors ship a separate Bark 3.0 Clean that drops fillers. We did not test it.
No word timings or speaker names yet, according to the authors' page. If your subtitles or minutes need them, they have to come from another tool.

Which GPU: none. Four processor threads did five minutes in 31 seconds

The smallest machine that worked had no graphics card. On four threads of a server processor, Bark transcribed the five-minute file in 31 seconds. On sixteen threads it took 14 seconds. The transcripts were word for word the same as on the GPU, on all 40 clips.

On a GPU, Bark is tiny. The model takes about 1.3 GB of memory, and with only Bark loaded the card never went above about 2.8 GB, under an eighth of its 24 GB.

To check smaller cards without having them, we capped how much of the 3090's memory Bark could use. That copies a smaller card's memory limit, not its slower chip. A cap of about 4 GB changed nothing: same transcripts, same speed.

Under a cap of about 2 GB, everything passed once long audio was cut into 60-second pieces, a setting in our example. Without the pieces, the five-minute file asked for too much memory at once and failed. With them, it passed well under the cap, and the 40 clips came out with the same transcripts as before. On the capped GPU, the pieces did not slow anything down.

We also tried to rent seven types of small card, from 6 to 20 GB, such as an RTX A2000, an RTX 3070 and an RTX 4000 Ada. In eight attempts, none was in stock. So we cannot name a specific small card as enough.

On InferenceKey: one short Python file, restarts in 8 seconds

One Python file, under 200 lines, serves Bark through Hugging Face's Transformers library, as its page promises. The usual serving tools do not run it. The file downloads the model, loads it and turns audio into text. Any program that already talks to OpenAI's transcription API can send it a file.

The first start took 322 seconds, about 300 of them installing software on a fresh machine. Downloading the model took 4 seconds, loading it 2.4. After that, restarts were ready in 7 to 8 seconds. Qwen3-ASR, which the platform runs without custom code, took 357 seconds on its first start. Both models shared the one 3090.

Two rough edges you will hit too:

Audio uploads stop at about 2 MB. That is about 65 seconds of uncompressed audio. Our five-minute WAV, 9.7 MB, was rejected as too large. The workaround is a compressed format: the same five minutes fit in 1.1 MB. Status: open. The example's README documents it.
Rerunning the example while the model is still deployed hangs the script. The model keeps answering, but the script waits for ten minutes. Workaround: delete the deployment before you run it again. Status: open.

The other problems we found are in the section for engineers below.

Should you use it? Yes for word-for-word English transcripts on small hardware

If you transcribe English meetings, calls or interviews and need every word as spoken, it is worth running. It made fewer verbatim errors than Qwen3-ASR-1.7B on our meetings and earnings calls.
If you want text people read without editing, expect "uh" and "you know" in the output and plan a cleanup step.
If your audio is not in English, look elsewhere.
If you have no spare GPU, a few server processor threads handle one recording faster than it plays.
If you ship it in a product, the license allows it with attribution.

You need an InferenceKey project, an audio file and an NVIDIA worker with about 2 GB free, or BARK_DEVICE=cpu for no GPU. To transcribe and score your own audio, run python publish.py once, then python main.py, from the SDK example.

For engineers

Model and files

Model card, NOTICE, Underdog release post (dated 15 October 2026, "The Underdog team"), Bark 3.0 small card, Parakeet TDT 0.6B v3.
0.6B parameters, English only, full precision (bf16). Repo ConwayResearch/Underdog-Bark-3.0-Pro, created and last modified 2026-10-15 (07:05:36Z / 07:05:51Z), sha 4b5c51e04aa8d16dda9ecdff71bc29f7360149e4, not gated. License cc-by-4.0, library transformers, pipeline automatic-speech-recognition, base_model: nvidia/parakeet-tdt-0.6b-v3 with base_model_relation: finetune. 1,079 downloads last month and 36 likes on 2026-10-27.
The repo is 2.49 GB in all, because it also carries Core ML and MLX copies. The PyTorch files the backend downloads are model.safetensors (1,254,196,636 bytes, bf16) plus configs and tokenizer, about 1.26 GB.
config.json: ParakeetForTDT, FastConformer encoder (24 layers, hidden 1024, 8 heads, 128 mel bins, subsampling 8) and a TDT decoder (2 layers, hidden 640, durations 0 to 4), vocab 8,193, transformers_version 5.19.0.
Attribution chain (NOTICE): nvidia/parakeet-tdt-0.6b-v3 (c) NVIDIA Corporation, CC-BY-4.0, and moondream/parakeet-ultra (c) Moondream, CC-BY-4.0. Changes: "post-trained and compressed by Conway Research".
Recommended load on the card: AutoProcessor plus ParakeetForTDT.from_pretrained(repo, dtype=torch.bfloat16).to("cuda"), mono 16 kHz input, 4,000 samples (0.25 s) of leading silence prepended, then model.generate(). Greedy decoding.
Runtimes on the card: Windows with NVIDIA CUDA (Python 3.11, torch==2.8.0 cu128, a BF16-capable GPU; float16 is an explicit alternative that needs its own accuracy validation; CPU with --device cpu --dtype float32), Mac Core ML (macOS 15+, tested on an M5 Max, about 1.23 GB download), iOS 18+ through FluidAudio ("Not yet tested on an iPhone or iPad"). The Underdog app runs it with MLX on Apple silicon.
Bark 3.0 family (release post): Bark 3.0, 163 MB, 4.94% average; Bark 3.0 Plus, 180 MB, 4.76%; Bark 3.0 Pro, 1.25 GB, 4.29%, "Hugging Face only"; Bark 3.0 Clean, 180 MB, 5.83%, drops fillers, the default in the Underdog app. The small Bark 3.0 ships as a packed model.bark file loaded with bark_loader.py. The release post also says "English only", "No word timings or speaker names yet", and that the small Bark 3.0 does 5 minutes in half a second on an M5 Max (595x, authors' figure, not the Pro).

The card's benchmark table (self-reported, not reproduced)

Full test sets, with cleaned versions of AMI, Earnings-22, GigaSpeech and VoxPopuli. The rows other than Bark are the leaderboard's published rows as of 9 October 2026. The Bark rows "use its scoring code and are not on the leaderboard yet". The card's full claim: "the lowest of any open model by the leaderboard's own scoring: 4.286 against 4.291 for Hojo-ASR-V1, a 12 GB download."

Model	Download	LS clean	LS other	AMI	Earnings-22	GigaSpeech	SPGISpeech	VoxPopuli	Avg
Bark 3.0 Pro	1,254 MB	1.38	3.11	7.16	5.65	7.46	3.54	1.70	4.29
Qwen3-ASR-1.7B	4,699 MB	1.26	2.94	8.31	5.84	7.22	2.57	2.85	4.43
Parakeet TDT 0.6B v3	2,508 MB	1.52	3.13	9.42	5.85	7.99	3.63	3.05	4.94
Whisper large-v3	9,261 MB	1.56	3.52	13.63	7.99	8.35	2.71	4.53	6.04
Hojo-ASR-V1	11,957 MB								4.29

Also on the card: Canary-Qwen 2.5B 4.55%, and paid APIs not in the table (OpenAI GPT-Transcribe 4.70%, AssemblyAI Universal-3.5 Pro 4.46%, Gladia Solaria-3 4.70%, Smallest.ai Pulse 4.54%, Meta Muse Voice Transcribe 4.93%). On DisfluencySpeech (250 clips, verbatim, fillers counted) the card reports 2.95%.

Parakeet TDT 0.6B v3's own card lists a 6.34% average with different per-set numbers. The likely reason is different (cleaned) set versions; we did not confirm it. The leaderboard Space is a Gradio app, and we did not read its current rows directly.

Our setup

One RTX 3090 24 GB on our cloud (driver 580.65.06, 21 vCPU AMD EPYC 7C13, 100 GB container disk, a PyTorch 2.8 CUDA 12.8 Ubuntu 24.04 image), 41 minutes in all. A local InferenceKey manager (from main at cc0024a4) bootstrapped it through dev tunnels. No code patch to the platform.
Bark: custom backend underdog-bark-pro 0.1.0, task_type audio2text, transformers 5.19.0, torch 2.8.0 cu128, bf16.
Qwen3-ASR-1.7B: built-in sglang backend, sglang 0.5.14, --trust-remote-code --mem-fraction-static 0.45, same setup as the SDK example sglang-qwen3-asr-private. It could not share Bark's custom backend because the qwen-asr package pins transformers 4.57.6.
Why a custom backend: vLLM, SGLang and llama.cpp do not serve Parakeet TDT models.
Clips: 8 per set from hf-audio/open-asr-leaderboard parquet shards (ami test-00002, earnings22 test-00001, gigaspeech test-00004, voxpopuli test-00001, librispeech test.other), seed 20261027, 4 to 20 s, 347.5 s and 924 words in all. Long file: 33 further Earnings-22 segments stitched with 0.4 s gaps, 303.4 s.
Scoring: jiwer after the Whisper English normalizer (whisper-normalizer). One request at a time, greedy decoding.
Before renting anything, the backend ran locally on CPU (torch 2.8.0+cpu) and transcribed two clips correctly.

Step by step with the SDK example

The example (commit fb18916b on main) contains backend.py, requirements.txt, publish.py, main.py, asr_eval.py (multipart call plus WER), compare_qwen3_asr.py (Qwen3-ASR-1.7B on sglang, same clips, side by side), README.md and .env.example.

cp .env.example .env              # tokens, project slug, IK_WORKER_ID, IK_AUDIO
python -m venv .venv && . .venv/bin/activate
pip install maturin requests jiwer whisper-normalizer
( cd ../../bindings/python && maturin develop --release )
python publish.py                 # once: uploads the backend if INFERENCEKEY_TENANT_ID and INFERENCEKEY_USER_TOKEN are set, else builds dist/*.tar.gz to upload from Dashboard -> Custom backends
python main.py                    # ensure -> wait_until_ready -> transcribe -> score -> delete
IK_KEEP_ALIVE=1 python main.py && python compare_qwen3_asr.py   # side by side

.env needs INFERENCEKEY_SDK_TOKEN, INFERENCEKEY_API_KEY, INFERENCEKEY_PROJECT, IK_WORKER_ID (an NVIDIA worker with a driver for CUDA 12.8 and Python 3.12) and IK_AUDIO (a file or a folder; a manifest.json with {"id", "ref"} rows turns on WER scoring). For publish.py to upload the backend itself, also set INFERENCEKEY_TENANT_ID and INFERENCEKEY_USER_TOKEN (a dashboard session token); without them, upload the dist/*.tar.gz it builds from Dashboard -> Custom backends. Set INFERENCEKEY_BASE_URL explicitly: the SDK control calls default to https://api.inferencekey.com, but the transcription call in main.py and compare_qwen3_asr.py falls back to https://cloud.inferencekey.com when it is unset. Any OpenAI client works against the endpoint:

curl -s "${INFERENCEKEY_BASE_URL:-https://api.inferencekey.com}/endpoint/$INFERENCEKEY_PROJECT/underdog-bark-pro/v1/audio/transcriptions" \
  -H "Authorization: Bearer $INFERENCEKEY_API_KEY" -F file=@call.opus -F model=default

The answer is {"text", "duration", "seconds", "rtfx", "chunks", "vram_peak_gib", "device", "dtype", "model"}.

What backend.py does: snapshot_download of the pinned revision with allow_patterns (PyTorch files only), ParakeetForTDT.from_pretrained in bf16 on CUDA (float16 fallback on pre-Ampere cards, float32 on CPU), a warm-up on 1 s of silence, then per job: decode with soundfile (librosa fallback), resample with soxr, prepend 0.25 s of silence, generate(). Knobs:

Variable	Default	Effect
`BARK_DEVICE`	`cuda`	`cpu` runs float32 with no GPU
`BARK_DTYPE`	`bfloat16` on CUDA	`float16` or `float32`
`BARK_VRAM_LIMIT_GIB`	unset	caps memory with `torch.cuda.set_per_process_memory_fraction`
`BARK_CHUNK_SECONDS`	600	cuts long audio into pieces of this length
`BARK_CPU_THREADS`	unset	thread count on CPU

Changing a BARK_* variable needs a delete and a fresh ensure().

Full measurements

Accuracy, 40 clips (summary.json per run):

Set	Words	Bark 3.0 Pro	Qwen3-ASR-1.7B
AMI (4 to 5 s)	130	11.54%	16.92%
Earnings-22 (7 to 11 s)	184	8.15%	10.87%
GigaSpeech (9 s)	198	3.54%	4.04%
VoxPopuli (8 to 13 s)	199	8.04%	5.53%
LibriSpeech test-other (4 to 19 s)	213	2.35%	1.88%
All (347.5 s)	924	6.28% (S 32, D 11, I 15)	7.03% (S 28, D 29, I 8)

Speed:

Bark, bf16: 4.864 s of GPU time for the 40 clips (median 0.118 s per clip), 71x real time. Round trip median 0.50 s (0.456 to 0.713 s, the first request 1.73 s), 20.81 s total. Panel tester on the earnings clip: 928 ms.
Qwen3-ASR-1.7B: round trip median 0.73 s (0.52 to 2.60 s), 30.61 s total. Panel tester: 1,039 ms. sglang does not report GPU time.
Five-minute file, one request: Bark 2.833 s GPU, 4.48 s round trip (107x). Qwen 3.71 s round trip, truncated output.

Long audio: Bark returned 715 words, 18.69% WER (S 39, D 22, I 62) against the 658-word stitched reference, and 17.78% with 60 s chunks. The alignment shows stretches present in the audio but missing from the reference and the other way round (Earnings-22 segment boundaries), so the absolute figure says more about the stitched reference than about the model. Qwen3-ASR through sglang 0.5.14 with default settings returned 212 words, ending "...Matthew Walker, Credit Suisse. Please go ahead,": 454 of 658 reference words missing (72.04%). We did not investigate the cause.

GPU memory: weights on the GPU after load 1.18 GiB. PyTorch peak allocated 1.243 GiB on the 40 clips, 2.151 GiB on the five-minute file in one request, 1.369 GiB with 60 s chunks. Card peak from nvidia-smi (1 s samples) 2,682 MiB (2.81 GB) with only Bark loaded, 17,027 MiB with Qwen3-ASR loaded beside it (sglang reserves 45% of the card by setting, so this is not Qwen's need). Transformers warns on every call that it uses the model-agnostic default max_length (1,000 to 1,300), as the authors' runner does. No truncation seen.

Time to ready: Bark first start 322 s (venv and pip of PyTorch with CUDA libraries and transformers about 300 s, snapshot download 4.0 s, load 2.4 s). Warm restarts 7.6 s (4 GiB cap), 7.3 s (2 GiB cap), 8.1 s (2 GiB cap plus chunks), 6.9 s (CPU, 16 threads), 6.7 s (CPU, 4 threads), 8 s (final main.py). Qwen3-ASR first start 357 s (sglang install about 235 s of it).

VRAM ladder:

GPU or cap	Config	Peak	Time	Output	Real or emulated
RTX 3090 24 GB	bf16, one request	2.151 GiB allocated, 2,682 MiB card	40 clips 4.864 s; 5 min 2.833 s (107x)	reference, 6.28%	real
4 GiB cap	bf16, one request	2.151 GiB	40 clips 4.909 s; 5 min 2.644 s	6.28%, identical texts	emulated
2 GiB cap	bf16, one request	1.243 GiB on clips	clips 4.889 s	clips OK; 5 min: `CUDA out of memory. Tried to allocate 476.00 MiB ... 2.00 GiB allowed`	emulated
2 GiB cap	bf16, `BARK_CHUNK_SECONDS=60`	1.369 GiB	clips 4.94 s; 5 min 2.476 s (123x)	identical texts on 40 clips	emulated
CPU, 16 threads, AMD EPYC 7C13	float32, 60 s chunks	no GPU	clips 20.478 s (17x); 5 min 14.082 s (21.5x)	identical texts on 40 clips	real
CPU, 4 threads	float32, 60 s chunks	no GPU	clips 37.934 s (9.2x); 5 min 30.817 s (9.8x)	identical texts on 40 clips	real
RTX A2000 6 GB, RTX 2000 Ada, RTX A4000, RTX 3070, RTX 3080, RTX 4070 Ti, RTX 4000 Ada	real small card			not run: no stock for any of them	real card, not tried

Not tried either: fp16 on a pre-Ampere card, int8, the smaller Bark 3.0 and Plus checkpoints (different model.bark format), the Apple Core ML and MLX paths.

Sample outputs

earnings22-01 (9.26 s): the two transcripts quoted in the narrative. Bark 14.3% (0.79 s round trip in the first run), Qwen 20.0%. Both add "Thank you", which the reference segment cuts off.
librispeech_other-03 (18.6 s): Bark "At a quarter to ten, a valet entered. He composed with a little groom ..." in 0.62 s round trip, 0% WER.

Demo video

148 s. Chapters: the model (the authors' page with on-screen credit, and their benchmark marked "not reproduced by us"), our test (both models on one RTX 3090, the earnings clip in 928 ms and 1,039 ms, the 40-clip WER) and which hardware. The video says "under three seconds" for five minutes of audio: 2.833 s of GPU time, 4.48 s round trip.

Problems found

2 MiB body limit on /v1/audio/transcriptions (open). POST /endpoint/.../v1/audio/transcriptions with a 9.7 MB WAV returned 413 Payload Too Large: Failed to buffer the request body: length limit exceeded. In crates/manager/src/api/openai.rs, only the chat and messages routes get DefaultBodyLimit::max(8 MiB). The transcriptions route keeps axum's 2 MiB default, about 65 s of 16-bit 16 kHz mono WAV. Workaround: Opus at 40 kbps (1.1 MB for 5 minutes), MP3, or split the file. The limit was confirmed in a later checkout of the manager; the build we tested was removed with its worktree.
Re-running ensure() with an unchanged spec on a ready custom-backend workload (open). wait_until_ready() stayed at [0s] scheduling for 10 minutes. The worker logged custom backend: driven by ProjectConfigSnapshot; skipping legacy LoadModel, and the endpoint kept serving (a direct call answered in 0.73 s). Workaround: delete the workload first. main.py always calls ensure() before wait_until_ready(), so transcribing without a deploy means editing the script.
Qwen3-ASR on sglang truncates a long single request (not investigated): 212 of about 700 words for the five-minute file with the example's defaults. A default sglang output limit is a guess we have not checked.
The dev machine's disk was full at the start (local MinIO answered XMinioStorageFull on the backend upload). We freed only our own files, then the upload worked.
No small GPU in stock for the real-card rung: seven card types (6 to 20 GB), eight attempts (RTX A4000 in two pools), all refused.

Limits of this test

40 clips and 924 words, one request at a time, greedy decoding. Uncleaned sets, so not comparable with the card's table.
The card's leaderboard numbers were not reproduced.
One real GPU (RTX 3090). Smaller GPUs only as emulated memory caps, which do not copy a slower chip.
Ran through a local InferenceKey manager on our cloud, not the hosted service.

Sources

Model card and files: ConwayResearch/Underdog-Bark-3.0-Pro, ConwayResearch/Underdog-Bark-3.0.
Release post: underdog.ai/bark.
Base model: nvidia/parakeet-tdt-0.6b-v3.
Leaderboard and test data: hf-audio/open_asr_leaderboard, dataset hf-audio/open-asr-leaderboard.
Where we spotted it: AI Search news video, 25 October 2026, Bark segment at 03:10 to 04:53.
Our code: SDK example, commit fb18916b.
Licenses: Bark 3.0 Pro CC-BY-4.0 (NVIDIA, Moondream, Conway Research). Qwen3-ASR-1.7B by the Qwen team, Apache-2.0 according to our SDK README.