Audio8: eight checkpoints, one broken link, and a 3B model with nowhere to ship

Over the last two months, Audio8 has open-sourced eight audio checkpoints across two tasks — automatic speech recognition from 0.1B to 3B, text-to-speech from 0.1B to 1B-scale — plus a run of ONNX, quantized, and iOS deployment variants on top. The announcement's own framing is that this is "more than a collection of model checkpoints": an end-to-end approach spanning model design, a technical report, deployment-aware export, optimized runtimes, and hardware-specific execution paths, with the ONNX/INT8/INT4/ANE variants adapting to different memory, compute, and power budgets. That is a checkable claim. A portfolio either has the deployment coverage it says it has, or it doesn't, and Hugging Face's API will say which.

So this piece checks it, one repo at a time. Every model under huggingface.co/Audio8 enumerated through api/models?author=Audio8, every repo's real file sizes pulled with ?blobs=true, every model.safetensors header read directly over HTTP range requests (the first 8 bytes give a header length, the next that-many bytes are JSON — shapes and dtypes, no download required). The result is a family that is genuinely generous at one end and genuinely absent at the other, an architecture (arkasr) that turns out to be shared, unmodified, across models built for entirely different tasks, and one promised deployment artifact that — checked the same way — simply isn't where its own model card says it is.

expand

The family, enumerated

api/models?author=Audio8&limit=100 returns 12 repos. Cross-referenced against search=ark-asr and search=Audio8 to catch anything the author filter alone might miss, and against every AutoArk-AI/... path model cards themselves link to (AutoArk-AI is the org's old name — every one of those paths 307-redirects cleanly to the matching Audio8/... repo, confirmed with curl -sI, except one covered below):

The two headline numbers in the announcement's family — ARK-ASR-3B's 16,688 downloads and Audio8-ASR-0.1B's 5,795 — both check out exactly against the live API. Two things are missing from this table on purpose. The first is a genuinely separate "0.3B" ASR model the announcement implies exists: it doesn't, as a distinct repo — it's hiding in two places at once, covered below. The second is GPA-v1.5's promised ONNX runtime bundle, which the API confirms exists, just not where its own README says it does.

What arkasr actually is

Three of the ASR repos and, unexpectedly, one of the "TTS" repos all declare "model_type": "arkasr" and "architectures": ["ArkasrForConditionalGeneration"] in their config.json. Reading the shape instead of trusting the label: arkasr is a Whisper-style audio encoder — mel spectrogram in, RoPE-augmented transformer layers, a stated whisper_config sub-block lifted straight from the Whisper config schema — feeding an MLP adapter that merges consecutive encoder frames by a merge_factor, producing embeddings that get spliced into a Qwen-style causal decoder's input sequence by replacing dedicated audio_token_id placeholder tokens. It's the exact mechanism the figure above draws, and it's genuinely the mechanism, not marketing: it's confirmed by the config.json on every one of these repos, not by the diagram alone.

// Audio8-ASR-0.1B/config.json (trimmed)
{
  "architectures": ["ArkasrForConditionalGeneration"],
  "model_type": "arkasr",
  "adapter_type": "qwen3_asr_mlp_tower",
  "audio_token_id": 151646,
  "merge_factor": 4,
  "hidden_size": 512,
  "num_hidden_layers": 8,
  "whisper_config": { "_name_or_path": "openai/whisper-small", "d_model": 768, "encoder_layers": 12 }
}

What's unusual is where else that exact config schema shows up. GPA-v1.5 — the newer of the two "General Purpose Audio" unified models, positioned for ASR and TTS (voice conversion is roadmapped) — carries the identical "model_type": "arkasr" and the identical auto_map class paths. That is not a coincidence of naming. Reading GPA-v1.5's own model.safetensors header and classifying every tensor by prefix:

The audio encoder, the decoder layer stack, and the adapter are bit-identical parameter counts, tensor shape for tensor shape, between a model whose whole job is transcription and a model whose job is transcription and speech synthesis. The only real difference is the embedding row: both configs declare tie_word_embeddings: true and share the same 163,958-token vocabulary and 896-wide hidden size, but ARK-ASR-0.6B's export serializes the tied tensor twice (model.embed_tokens.weight and lm_head.weight as separate 146,906,368-parameter tensors) where GPA-v1.5's export deduplicates it to one copy — an export-time difference, not an architectural one. Once that redundant copy is removed, ARK-ASR-0.6B's true unique parameter count is 1,152,556,800 — identical, to the parameter, with GPA-v1.5's own 1,152,556,800.

The 0.3B the announcement implies exists turns out to live in two different places, and they're not the same model. Audio8-ASR-0.1B's own README states it directly, in its own words: "Language-model parameters: 103,502,336 (about 0.104B)" next to "End-to-end unique parameters: 323,990,528 (about 0.324B)" — the smallest ASR checkpoint's true deployed size, once its Whisper-small encoder and adapter are counted, already rounds to roughly a third of a billion. Separately, and unrelated to that arithmetic: GPA — the earlier, plain-qwen3-architecture "General Purpose Audio" model, not GPA-v1.5 — is a real, distinct 312,625,152-parameter checkpoint (read from its own safetensors header, bf16), matching the GPA-v1.5 paper's own description of the family: "a lightweight 0.3B-parameter variant optimized for edge and resource-constrained environments." Both numbers are genuinely 0.3-something-B and genuinely Audio8's; neither is the other.

The deployment matrix

Read the full grid and the "deployment-aware" framing holds unevenly by design tier rather than uniformly across the family. It is most generous exactly where it matters most for a phone: the smallest ASR checkpoint gets a bundled ONNX package and a from-scratch Swift package with a Core ML audio tower and a minimal iOS demo app. It thins to one precision by the middle tier (0.6B ASR gets INT8 ONNX only; 0.6B TTS gets INT4 ONNX only, the opposite ladder rung from the 0.1B TTS checkpoint's INT8-only package — the two TTS quantization ladders never overlap at all). And it is completely absent for the checkpoint carrying the most download weight of the entire release.

What INT8 and INT4 actually buy

The Audio8-ASR-0.1B ONNX bundle is the one repo in the family that ships fp32, INT8, and INT4 side by side, which makes it the cleanest place to measure quantization's actual payoff rather than estimate it:

Real ratios, not the nominal 4× and 8× byte-width math suggests — close enough that the difference is mostly quantization overhead (scale/zero-point tensors, a handful of ops left at higher precision) rather than anything surprising. The default runtime path this repo actually ships is INT8 decoder plus INT8 tower; INT4 exists in the bundle as an explicit lower-memory option, not the default.

GPA's own multi-precision bundle is worth a specific flag here, because its folder naming doesn't match its own contents. GPA_TTS/GPA_TTS_INT8/model/ holds two files: spark_detokenizer_int8.onnx.data (165.2 MB, genuinely INT8) sitting next to qwen_int4_ort/model.onnx.data (202.6 MB) — an INT4-quantized decoder, nested inside the directory labeled INT8. The bundle is real and the quantization is real; the label describing it as one precision is not.

The hole: ARK-ASR-3B has nowhere to go

ARK-ASR-3B is the most-downloaded model Audio8 has shipped — 16,688 downloads, 99 likes, well ahead of every other repo in the family — and it is the one checkpoint with zero official deployment variants of any kind. No ONNX export under Audio8/ or the old AutoArk-AI/ namespace, no INT8, no INT4, no iOS build. Checked directly: Audio8/ARK-ASR-3B-onnx-runtime, Audio8/ARK-ASR-3B-ONNX, AutoArk-AI/ARK-ASR-3B-onnx-runtime, and AutoArk-AI/ARK-ASR-3B-int8-onnx all return HTTP 401 (nonexistent) from the Hugging Face API.

The gap hasn't gone unnoticed — it's just been filled by other people. search=ark-asr on the Hugging Face API turns up Masterx/ark-asr-3b-onnx, cstr/ark-asr-3b-GGUF, harshav/ARK-ASR-3B-GGUF, harshav/ARK-ASR-3B-CoreAI, and hypermind-official/ARK-ASR-3B-NoTranslate — five independent, unofficial conversions of the model with the most demand in the whole portfolio, none of them from Audio8. A 3B decoder plus the same shared 637.0M-parameter Whisper-large-scale encoder used at 0.6B is a real deployment target — it's the kind of model an ONNX or INT8 export could plausibly get onto a high-end phone or a small GPU — and community members have decided it's worth doing that work themselves rather than wait.

A promised ONNX bundle that isn't where the card says

GPA-v1.5's model card is explicit about where its runtime-optimized assets live: "Runtime-optimized ONNX assets are published separately at AutoArk-AI/GPA-v1.5-onnx-runtime." That path resolves — but not to anything Audio8 or AutoArk-AI hosts.

$ curl -sI https://huggingface.co/api/models/AutoArk-AI/GPA-v1.5-onnx-runtime
HTTP/2 307
location: /api/models/Edge0/GPA-v1.5-onnx-runtime

Edge0/GPA-v1.5-onnx-runtime is a real, working repo — a genuine ONNX bundle (genai_fp16_qwen/, genai_int4_qwen/, a Spark-tokenizer voice directory, 6.74 GB total, matching GPA-v1.5's own README structure almost line for line, and carrying the same arxiv:2601.10770 tag as the checkpoint it serves) — but it's owned by a third-party Hugging Face account with 20 downloads and 22 likes, a small fraction of the checkpoint's own traffic, and it is not part of the Audio8 org. Every other AutoArk-AI/... link this piece followed 307-redirects cleanly to the matching Audio8/... repo; this is the one that doesn't. Whichever way that repo ended up under a different account, the practical result is the same: enumerate Audio8's own org by API — exactly what "the whole family" means for this piece — and GPA-v1.5 has no deployment-optimized artifact inside it at all.

Fitting a phone, a laptop, a workstation

expand

Package size on disk and live memory footprint are related but different numbers, and Audio8's own cards give real values for both worth keeping separate. The phone reference line above, 224 MB, is that screenshot's own peak — measured on a physical iPhone during a live microphone transcription, against the card's stated target of "roughly 200 MB." The laptop reference line, 1.23 GB, is the 0.6B TTS INT4 card's own number: "the service used about 1004 MiB after loading and approximately 1.1-1.2 GiB at synthesis peak" on a 16 GB Apple M2 MacBook Air, with voice registration briefly reaching about 1.55 GiB before the codec encoder releases its session. Both are Audio8's own measurements, not this piece's estimate.

Only three packages in the entire family sit near or under the phone line, and all three are deployment variants of the smallest checkpoint in their own line — nothing at 0.6B or above has ever shipped small enough to approach it. Past the laptop line, the field is almost entirely base checkpoints: no quantized artifact anywhere in the family sits between roughly 1.7 GB and 7.6 GB. ARK-ASR-3B occupies that upper end alone, with no smaller sibling of its own.

Licenses: the two restricted checkpoints are the two smallest

Across all 12 repos, exactly two license terms depart from plain Apache-2.0, and both land on the smallest checkpoint in their respective line — the ones best positioned, by size, to actually run on a phone.

Audio8-ASR-0.1B and both of its deployment variants (the ONNX bundle, the iOS ANE package) are CC-BY-NC-4.0 — noncommercial only. Every larger ASR checkpoint (ARK-ASR-0.6B, ARK-ASR-3B, and 0.6B's own ONNX export) is Apache-2.0. Audio8-TTS-Preview-0.1b carries a custom "Audio8 Community License v1.0": free for noncommercial use and free for commercial use under roughly two million US dollars a year in entity revenue, but a separate written commercial license is required above that threshold. Its own 0.6B sibling, and its own official INT8 ONNX export, are both plain Apache-2.0 — a looser license than the base checkpoint it was quantized from. Neither inconsistency is a legal problem to flag; it's a plain fact worth having in view before shipping anything: the two checkpoints small enough to be candidates for a commercial phone app are exactly the two under the most restrictive terms in the portfolio, and one of those restrictions doesn't survive its own official ONNX conversion.

Is there a technical report?

Yes, for most of the family — checked by fetching both cited arXiv abstract pages directly rather than trusting the badge. arXiv:2605.28139, "Data-Efficient On-Policy Distillation for Automatic Speech Recognition" (Lin, Wang, Cai, Zeng), returns HTTP 200 and its own abstract describes exactly the arkasr family: a 0.6B-parameter audio-conditioned language model trained on 100k hours of speech, transferring recognition ability from a Qwen-ASR teacher through on-policy distillation, and beating the same-scale Qwen3-ASR-0.6B baseline on four of five evaluation sets using roughly 1/200th the labeled-audio budget Qwen3-Omni's own encoder reportedly used. This paper covers Audio8-ASR-0.1B, ARK-ASR-0.6B, and ARK-ASR-3B, and its GitHub project, AutoArk/open-audio-opd, is the one every ASR model card links its inference code to.

A second, separate paper, arXiv:2601.10770, "Unifying Speech Recognition, Synthesis and Conversion with Autoregressive Transformers" (Cai, Lin, Wang, Fu, Zeng), also returns 200 and is the citation on GPA-v1.5's own card — its abstract is what confirms the "0.3B-parameter variant optimized for edge and resource-constrained environments" language quoted above, and describes the shared-discrete-token, instruction-driven-task design this piece's tensor-count comparison confirms independently. What doesn't have a report: the plain-qwen3 GPA v1 and the arktts-architecture Audio8-TTS-Preview line (0.1b and 0.6b, and their ONNX exports) carry no arXiv badge on any of their cards. The technical report exists and is reachable — for two of the family's four architecture lines, both of which happen to be the two carrying the arkasr name.

Sori-1B: a different task wearing similar words

Sori-1B is not an Audio8 release — it's from Seoul National University's Human Interface Lab, published under a gated, noncommercial license (sori-1b-noncommercial, built on NVIDIA's frozen, academic-only Audio Flamingo Next encoder plus a fully fine-tuned, Apache-2.0 SmolLM2-360M decoder) — but it's the nearest neighbor to Audio8's ASR line in the space of "small open audio-language models," and the two differ in a way worth being precise about. Sori-1B's own pipeline tag is audio-text-to-text, not automatic-speech-recognition. Its README frames it as a model addressed like a Python interpreter: a sound clip is a value in a session, transcribe(audio) is one typed function call among many (segments, count("speakers"), count("words"), arbitrary slicing by time), and the model's real job is answering questions about what's audible — captioning, counting, verifying a claim — of which transcription is one capability, not the point of the checkpoint.

That distinction shows up in how the checkpoint itself is built and shipped, not only in its marketing copy. It's a single 4,220,042,636-byte (3.93 GB), fp32, monolithic checkpoint, by explicit design choice stated in its own README — "the model is fp32 end to end, so it gives the same answer on any device or batch size" — favoring determinism over efficiency. There is no ONNX export, no quantized variant, no edge build, and (Sori-1B being gated) this piece couldn't read its safetensors header directly to independently verify parameter dtype the way it did for every Audio8 checkpoint above; the byte count and the card's own fp32 claim are what's reported here. At 388 downloads and 25 likes, it reads as exactly what its license terms say it is: an academic research release, not a deployment portfolio. Next to Audio8's ASR line — three sizes, six deployment variants, one shared architecture reused across two tasks, checkable byte-for-byte through a public API — Sori-1B is a useful reminder that "small audio-language model" is not one task. Audio8 optimized for shipping transcription onto constrained hardware; Sori-1B optimized for a single, reproducible, general-purpose instrument for asking a model what it heard.

Checked, in one table

The take

Tested against the artifacts rather than the announcement's own prose, Audio8's deployment story is real where it's easiest to be real — at the smallest size in each line, where a single team can plausibly ship a Core ML build and three ONNX precisions in the same sprint — and it thins out exactly where scaling makes deployment work harder, not easier. That's not a portfolio-wide failure; it's an uneven one, and the unevenness itself is the finding: a 0.1B model with a full iOS SDK sitting in the same org as a 3B model with none, a unified checkpoint whose own promised runtime lives under someone else's account, and a naming convention that's honest for the two GPA checkpoints and consistently short for the three ASR ones, by an amount a shared, fixed-size Whisper encoder explains almost exactly.

None of this is uncheckable. Every number above came from the same public API anyone evaluating these models could query themselves — repo listings, blob sizes, safetensors headers, arXiv abstract pages, a handful of curl -sI redirects. That's arguably the strongest thing in Audio8's favor here: a portfolio built this checkably doesn't have anywhere to hide a gap, including the ones its own announcement didn't mention.

This site has covered nearby ground before. Nemotron-Audex is the same "one decoder, continuous audio in, discrete tokens out" design pushed onto a 30B MoE, which makes a useful contrast in scale for what arkasr's Whisper-encoder-plus-adapter pattern looks like at the other end. Breeze TTS 2 is the same read-the-config-and-the-safetensors-headers method applied to a different TTS stack, including its own gap between a claimed number and a measured one. And Qwen Audio 3.0 TTS is worth reading against arktts's Mamba-hybrid dual-AR codec design as a second, quite different answer to the same "how does a language model emit audio" question.

Sources: the Audio8 organization on Hugging Face (huggingface.co/Audio8), enumerated via api/models?author=Audio8 and, per repo, api/models/<repo>?blobs=true; the model cards and config.json for Audio8-ASR-0.1B, ARK-ASR-0.6B, ARK-ASR-3B, Audio8-ASR-0.1B-onnx-runtime, Audio8-ASR-0.1B-iOS-ANE, ark-asr-0.6b-int8-onnx, Audio8-TTS-Preview-0.1b, Audio8-TTS-Preview-0.6b, audio8-TTS-0.1B-ONNX-INT8, Audio8-TTS-Preview-0.6B-ONNX-INT4, GPA, and GPA-v1.5; model.safetensors headers read directly via HTTP range requests for Audio8-ASR-0.1B, ARK-ASR-0.6B, ARK-ASR-3B (both shards, cross-checked against model.safetensors.index.json's own total_parameters field), GPA, GPA-v1.5, Audio8-TTS-Preview-0.1b, and Audio8-TTS-Preview-0.6b; Edge0/GPA-v1.5-onnx-runtime and its own ?blobs=true listing; arXiv:2605.28139, "Data-Efficient On-Policy Distillation for Automatic Speech Recognition" (Lin, Wang, Cai, Zeng); and arXiv:2601.10770, "Unifying Speech Recognition, Synthesis and Conversion with Autoregressive Transformers" (Cai, Lin, Wang, Fu, Zeng). The comparison model is snkii/Sori-1B and its own model card. The deployment-matrix, name-vs-reality, and size-vs-device-fit diagrams are original, built from the sources above.