# Audio8: eight checkpoints, one broken link, and a 3B model with nowhere to ship
> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.thesatyajit.com/articles/audio8
> date: 2026-09-08
> tags: audio, asr, tts, on-device, quantization, explainer
Over the last two months, [Audio8](https://huggingface.co/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.
## 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):
| Checkpoint | Task | Arch | Downloads | Likes | Size | License |
|---|---|---:|---:|---:|---:|---|
| Audio8-ASR-0.1B | ASR | `arkasr` | 5,795 | 81 | 707.8 MB | CC-BY-NC-4.0 |
| Audio8-ASR-0.1B-onnx-runtime | ASR (ONNX) | — | 130 | 14 | 2.80 GB | CC-BY-NC-4.0 |
| Audio8-ASR-0.1B-iOS-ANE | ASR (Core ML + ONNX) | — | 38 | 12 | 416.9 MB | CC-BY-NC-4.0 |
| ARK-ASR-0.6B | ASR | `arkasr` | 1,698 | 54 | 2.44 GB | Apache-2.0 |
| ark-asr-0.6b-int8-onnx | ASR (ONNX INT8) | — | 61 | 25 | 1.65 GB | Apache-2.0 |
| ARK-ASR-3B | ASR | `arkasr` | **16,688** | **99** | 7.59 GB | Apache-2.0 |
| Audio8-TTS-Preview-0.1b | TTS | `arktts` | 8,209 | 210 | 1.58 GB | Audio8 Community v1.0 |
| audio8-TTS-0.1B-ONNX-INT8 | TTS (ONNX INT8) | — | 1,750 | 66 | 818.4 MB | Apache-2.0 |
| Audio8-TTS-Preview-0.6b | TTS | `arktts` | 12,309 | 392 | 2.39 GB | Apache-2.0 |
| Audio8-TTS-Preview-0.6B-ONNX-INT4 | TTS (ONNX INT4) | — | 1,470 | 54 | 968.3 MB | Apache-2.0 |
| GPA | ASR+TTS+VC | `qwen3` | 74 | 34 | 6.42 GB | Apache-2.0 |
| GPA-v1.5 | ASR+TTS(+VC) | `arkasr` | 56 | 27 | 3.94 GB | Apache-2.0 |
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.
```json
// 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:
| Component | ARK-ASR-0.6B | GPA-v1.5 |
|---|---:|---:|
| `audio_encoder.whisper.*` | 636,968,960 | 636,968,960 |
| `model.layers.*` / `model.norm` | 357,898,112 | 357,898,112 |
| `audio_encoder.adapting.*` | 10,783,360 | 10,783,360 |
| `model.embed_tokens` / `lm_head` | 293,812,736 (embedding stored twice) | 146,906,368 (stored once) |
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:
| Graph | fp32 | INT8 | INT8 ratio | INT4 | INT4 ratio |
|---|---:|---:|---:|---:|---:|
| audio tower (`audio_hidden.onnx`) | 839.5 MB | 223.8 MB | 3.75× | — | — |
| decoder prefill cache | 395.0 MB | 100.0 MB | 3.95× | 53.1 MB | 7.45× |
| decoder decode cache | 395.0 MB | 100.0 MB | 3.95× | 53.1 MB | 7.44× |
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](https://huggingface.co/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
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](https://huggingface.co/snkii/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
| Claim | Status |
|---|---|
| "More than a collection of checkpoints" — deployment-aware ONNX/INT8/INT4/ANE variants | Holds strongly at the smallest tier of each line, thins to one precision by the middle tier, and is completely absent for ARK-ASR-3B, the family's most-downloaded model |
| A technical report exists | Holds for two of four architecture lines (`arkasr`-ASR: 2605.28139; GPA-v1.5: 2601.10770), both reachable and both matching their cited claims. No report for GPA v1 or the `arktts` TTS-Preview line |
| `arkasr` architecture spans ASR and TTS | Holds, exactly — GPA-v1.5's encoder, decoder layer stack, and adapter are bit-identical parameter counts to ARK-ASR-0.6B's own |
| A 0.3B model exists, per the announcement | Holds, in two unrelated forms: Audio8-ASR-0.1B's own true end-to-end size (0.324B) and the separate GPA checkpoint (0.313B, confirmed against its own paper's language) |
| "0.1B" / "0.6B" / "3B" name the deployed checkpoint | Understates by 3.13×, 1.92×, and 1.35× respectively — a fixed ~637M-parameter shared audio encoder becomes a shrinking fraction of an ever-larger decoder |
| GPA-v1.5's ONNX runtime is published where the card says | Does not hold — the linked path redirects to a third-party account, not to Audio8 or AutoArk-AI |
| ARK-ASR-3B has an official deployment path | Does not hold — zero ONNX/INT8/INT4/ANE variants exist under Audio8's org, despite it being the most-downloaded checkpoint in the family |
## 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](/articles/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](/articles/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](/articles/qwen-audio-3-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/?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](https://arxiv.org/abs/2605.28139), "Data-Efficient
On-Policy Distillation for Automatic Speech Recognition" (Lin, Wang, Cai, Zeng); and
[arXiv:2601.10770](https://arxiv.org/abs/2601.10770), "Unifying Speech Recognition, Synthesis and
Conversion with Autoregressive Transformers" (Cai, Lin, Wang, Fu, Zeng). The comparison model is
[snkii/Sori-1B](https://huggingface.co/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.*