Accept the Arc licence (non-commercial use only)

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Arc is licensed by Whissle Inc. under CC BY-NC 4.0 and the Whissle terms in LICENSE, for non-commercial use only. Commercial use (in or with a product or service, paid or hosted services, business use, or commercial use of outputs) requires a separate written licence from Whissle Inc.: contact ksingla@whissle.ai. Whissle Inc. keeps all rights not expressly granted; no patent or trademark rights are granted.

Arc v1 (Arc Mini and Arc Transcriber): one streaming model for transcript, names, numbers, speakers, tags and events

Arc is an all-in-one streaming audio model. You give it audio and, optionally, your list of names and some context. One model then returns, as the audio plays:

a transcript with inline tags on names, numbers and entities ([Theo Brandt](name: Theo Brandt), [102 to 98](score: 102-98));
names linked to your own list (people, teams, organisations, places, ...), and numbers with their values (scores, clocks, money, dates, durations, percentages, ...);
speakers and their roles, and per-utterance acts, intents and segment labels;
sound and channel events (silence, telephone / narrowband audio, degraded audio, clipping, plus many experimental labels);
device-directed speech (is this utterance addressed to an assistant?);
context memory: the decoder can take your names, terms, a topic and the text said so far.

Arc v1 has two models. Both use the same Python package and the same output schema.

model	`--backbone`	folder	download	runs on	choose it when
Arc Mini	`mini` (alias `edge`)	`mini/`	about 71 MB	CPU (files at about 0.3x real time on 4 cores, live streaming real time on 4 cores without partials); GPU optional	apps, laptops, on-device, low latency
Arc Transcriber (full)	`full` (aliases `parakeet`, `server`)	`full/`	about 77 MB + NVIDIA Parakeet-TDT 0.6B v2 encoder (about 2.5 GB, fetched from Hugging Face on first use)	GPU recommended; CPU works for files	best transcript and name accuracy

Coming next: Arc Transcriber Edge, a 4-bit version of the full model for Android, Mac and low-cost cloud serving.

English, 16 kHz mono (other rates are resampled). Licence: CC BY-NC 4.0, non-commercial use only (see Licence).

Quick start

pip install git+https://github.com/WhissleAI/arc_transcriber
hf auth login        # accept the terms on this page first (approval is automatic)

arc-transcribe meeting.wav                                         # Arc Mini, CPU
arc-transcribe game.wav --domain nba --names roster.txt            # with your name list
arc-transcribe call.wav --backbone full --device cuda              # Arc Transcriber (full)
arc-transcribe --mic --context "Whissle, Arc, Jane Doe"             # live microphone, with context terms
arc-transcribe meeting.wav --format json -o meeting.json           # full records

from arc_audio import Arc, load_audio

arc = Arc.from_pretrained("WhissleAI/arc-v1.1", backbone="mini", threads=4)
# Arc Transcriber: Arc.from_pretrained("WhissleAI/arc-v1.1", backbone="full", device="cuda")
names = ["Jane Doe", {"name": "Harbor City Hawks", "kind": "team", "aliases": ["Hawks"]}]

# whole file
out = arc.predict("game.wav", domain="nba", names=names)
for u in out["transcript"]:
    print(u["start"], u["text"], u.get("device_directed"))
print(out["names"], out["numbers"], out["audio_events"])

# live: feed 100 ms chunks, get new records back
s = arc.stream(domain="meeting", names=names, auto_prev=True)
s.set_context(kb=["Whissle", "Arc"], kb_type=["org", "product"])      # context for the decoder (names, terms)
wav = load_audio("meeting.wav")
for i in range(0, len(wav), 1600):
    new = s.feed(wav[i:i + 1600])        # dict of new transcript lines, names, numbers, events, ...
final = s.flush()

Context for the decoder (both models):

arc.set_context(names=[...], terms=[...], topic="meeting", previous_text="...", auto_prev=True) applies to every later call.
Stream.set_context(...) changes it mid-stream.
names / terms are things the speakers may say; topic is a short domain hint; auto_prev=True feeds back what was already said (context memory).
Separately, names= on predict() / stream() is your name list for linking. Mentions are linked to it, and a fuzzy / phonetic snap step fills links the model missed (via: "snap"; turn it off with kb_snap=False).

Results

Public test sets

All other systems were run once with the same protocol. What the tables show, including where Arc is behind:

Arc Transcriber beats both raw Parakeet-TDT 0.6B v2 (the encoder it uses) and Whisper large-v3-turbo on AMI meetings (-3.3 and -3.5 points, both significant) and Whisper large-v3-turbo on VoxPopuli; it matches them on SLURP and Earnings-21 and trails them on LibriSpeech read speech.
Arc Mini has a higher word error rate than Moonshine base and Whisper base.en on every set, and than Moonshine tiny on most sets; it beats Moonshine tiny on SLURP. Its value is in the extra outputs from one small streaming model, not in raw word error rate.
Whisper large-v3-turbo + a separate NER model finds number values on Earnings-21 clearly better than Arc (value recall 84.1 % vs 68.2 % for Arc Transcriber) and has a higher name F1 (47.4 vs 41.9). On SLURP intents, a text classifier on the transcript of any of the ASR systems tested beats Arc's streaming intent read-out (Arc Transcriber: 56.6 %).
pyannote 3.1 is far ahead of Arc on speaker diarization (AMI DER 10.2 % vs 42.8 % for Arc Transcriber).

All numbers below were measured by us with one shared protocol for every system (same audio, same reference, same normaliser, same scorer). Every set is evaluated on its public test split (subsets as stated). 95% confidence intervals are paired bootstrap intervals over test items. 'n/c' = not computed.

Word error rate (%, lower is better)

system	LibriSpeech test-clean	LibriSpeech test-other	VoxPopuli test	SLURP test	Earnings-21 (long-form)	AMI test (long-form, headset mix)
Arc Mini (on-device, streaming)	8.5	22.9	12.4	39.9	24.8	35.3
Arc Transcriber (Parakeet encoder)	3.9	6.1	6.7	16.1	11.5	21.3
Parakeet-TDT 0.6B v2	1.6	3.3	5.0	16.2	11.1	24.6
Whisper large-v3-turbo	1.8	4.0	9.6	15.6	11.7	24.8
Whisper small.en	2.9	6.7	6.8	21.5	14.1	29.1
Whisper base.en	4.2	9.8	8.2	29.2	16.0	29.5
Moonshine base	3.2	8.2	9.0	33.5	16.6	28.3
Moonshine tiny	4.6	11.8	11.8	45.3	22.6	31.9
test items / hours	500 / 1.09 h	500 / 0.90 h	400 / 0.77 h	600 / 0.47 h	39 / 3.25 h	12 / 1.00 h

Paired differences (percentage points, A minus B; negative = A better):

comparison	LibriSpeech test-clean	LibriSpeech test-other	VoxPopuli test	SLURP test	Earnings-21 (long-form)	AMI test (long-form, headset mix)
Arc Transcriber vs Parakeet-TDT 0.6B v2	+2.2 [1.8, 2.6]	+2.7 [2.2, 3.2]	+1.7 [1.2, 2.2]	-0.1 [-1.8, 1.6]	+0.4 [0.0, 0.8]	-3.3 [-4.4, -1.8]
Arc Transcriber vs Whisper large-v3-turbo	+2.1 [1.7, 2.5]	+2.1 [1.6, 2.6]	-2.9 [-5.1, -1.0]	+0.5 [-1.4, 2.5]	-0.2 [-0.8, 0.4]	-3.5 [-4.7, -2.2]
Arc Mini vs Moonshine tiny	+3.9 [3.2, 4.6]	+11.1 [9.8, 12.5]	+0.7 [-0.4, 1.7]	-5.5 [-8.9, -2.1]	+2.2 [-1.8, 4.9]	+3.3 [1.7, 4.9]
Arc Mini vs Moonshine base	+5.3 [4.7, 6.0]	+14.7 [13.3, 16.1]	+3.4 [2.6, 4.4]	+6.3 [3.2, 9.6]	+8.2 [6.3, 10.3]	+7.0 [4.6, 9.0]
Arc Mini vs Whisper base.en	+4.3 [3.6, 5.1]	+13.1 [11.7, 14.5]	+4.2 [3.4, 5.1]	+10.6 [7.2, 14.1]	+8.8 [6.7, 11.2]	+5.7 [3.1, 8.3]

Protocol: Whisper English text normaliser on reference and hypothesis; WER = total errors / total reference words per set. Long recordings (Earnings-21: one 300 s segment from each of 39 test calls; AMI: twelve 300 s segments from the official test meetings) are cut by the same pause-based segmenter (<= 15 s pieces) for every system; utterances of 30 s or less are decoded whole by the baseline models. Subsets: LibriSpeech 500 utterances each, VoxPopuli 400 utterances of 0.6-12.7 s, SLURP 600 recordings (headset and far-field), seeded random samples. Baselines: greedy decoding as published. Arc: beam 4.

Names and numbers in the transcript: Earnings-21 (39 test segments, 300 s each)

Gold: 387 person / organisation / product mentions and 515 numbers with a checkable value, from the corpus' reference entity annotation.

system	how entities are produced	name recall	name precision	name F1	number value recall	number value precision
Arc Mini (on-device, streaming)	one model (inline tags)	31.0 [23.9, 39.5]	22.2	25.9	72.2 [67.7, 77.0]	50.2
Arc Transcriber (Parakeet encoder)	one model (inline tags)	45.5 [38.8, 54.0]	38.9	41.9	68.2 [62.5, 74.5]	57.6
Whisper large-v3-turbo	ASR + separate NER model	49.6 [41.8, 58.0]	45.4	47.4	84.1 [78.2, 89.4]	84.1
Parakeet-TDT 0.6B v2	ASR + separate NER model	46.0 [38.1, 54.5]	40.8	43.3	66.2 [57.9, 75.0]	71.0
Whisper small.en	ASR + separate NER model	41.9 [34.9, 49.4]	41.6	41.8	81.9 [76.1, 87.3]	81.8
Whisper base.en	ASR + separate NER model	34.9 [28.4, 41.6]	36.0	35.4	79.6 [73.6, 85.1]	78.5
Moonshine base	ASR + separate NER model	31.8 [25.5, 38.8]	33.3	32.5	66.8 [58.4, 75.3]	64.9
Moonshine tiny	ASR + separate NER model	28.4 [22.2, 35.1]	29.4	28.9	63.1 [55.7, 70.9]	60.6
reference transcript	reference transcript + NER (upper bound of the two-model approach)	72.6 [64.6, 80.2]	62.4	67.1	88.5 [83.7, 93.3]	88.0

Paired differences (points):

comparison	name recall	name F1	number value recall
Arc Transcriber vs Whisper large-v3-turbo + NER	-4.1 [-11.1, 2.8]	-5.5 [-11.5, -0.1]	-15.9 [-22.6, -9.1]
Arc Transcriber vs Parakeet-TDT 0.6B v2 + NER	-0.5 [-7.3, 6.7]	-1.3 [-7.5, 4.9]	+1.9 [-3.5, 6.6]
Arc Mini vs Whisper large-v3-turbo + NER	-18.6 [-26.1, -10.6]	-21.5 [-27.4, -15.7]	-11.8 [-18.0, -5.8]
Arc Mini vs Parakeet-TDT 0.6B v2 + NER	-15.0 [-22.6, -7.0]	-17.4 [-24.2, -10.9]	+6.0 [-2.6, 14.3]
Arc Mini vs Whisper base.en + NER	-3.9 [-9.8, 2.4]	-9.5 [-14.1, -4.6]	-7.4 [-13.3, -1.1]
Arc Mini vs Moonshine base + NER	-0.8 [-6.8, 5.5]	-6.7 [-11.2, -2.2]	+5.4 [-2.6, 13.6]

Protocol: matching inside each 300 s segment, time-free; a name matches when one normalised word sequence contains the other; numbers match on value (one value parser for every system). NER = an off-the-shelf OntoNotes-5 RoBERTa-base tagger (PERSON / ORG / PRODUCT / WORK_OF_ART; MONEY / PERCENT / CARDINAL / ORDINAL / DATE / QUANTITY). Precision is a lower bound for every system (the reference annotation leaves out generic business terms).

SLURP intents (60 intents; recordings from the SLURP test split)

786 test utterances; majority-class accuracy 8.4.

system	approach	accuracy	macro-F1
Arc Mini (on-device, streaming)	one model, from audio (streaming read-out)	49.8 [46.6, 52.8]	42.4
Arc Transcriber (Parakeet encoder)	one model, from audio (streaming read-out)	56.6 [53.0, 60.1]	48.5
reference transcript	text classifier on the transcript (upper bound)	84.5 [81.8, 87.1]	81.2
Whisper large-v3-turbo	text classifier on the transcript	77.3 [73.7, 80.9]	73.2
Parakeet-TDT 0.6B v2	text classifier on the transcript	76.2 [72.4, 79.8]	73.6
Whisper small.en	text classifier on the transcript	72.1 [68.5, 75.8]	68.9
Whisper base.en	text classifier on the transcript	66.5 [63.0, 70.0]	66.8
Moonshine base	text classifier on the transcript	63.5 [59.5, 67.1]	61.5
Moonshine tiny	text classifier on the transcript	56.4 [52.7, 60.4]	53.7

Text classifier: TF-IDF + logistic regression trained on the SLURP training transcripts (same 60 intents).

Speaker diarization, AMI test meetings (twelve 300 s segments, headset mix)

system	DER % (all segments)	missed / false alarm / confusion %	segments
Arc Mini (on-device, streaming)	44.8	7.0 / 3.5 / 34.4	12
Arc Transcriber (Parakeet encoder)	42.8	6.6 / 3.9 / 32.3	12
pyannote 3.1 (diarization only)	10.2	4.1 / 2.2 / 3.8	12

DER at 10 Hz frames, best one-to-one speaker mapping, overlapped speech excluded, no collar; Arc models are streaming and audio-only, pyannote is offline.

Our own dev sets (not public benchmarks)

Internal human-labelled multi-domain set (sports, news, talk, meetings, legal, voice assistant)

inline span F1 (overlap)	Arc Mini
names (3637 gold spans)	67.8
numbers (2630 gold spans)	77.1

Arc Transcriber was not scored on this set with its shipped files, so it has no column here.

Caveat: Arc Mini's decoding thresholds were tuned on this set, so these numbers are optimistic; it is not a public benchmark.

Device-directed operating points (Arc Transcriber)

Measured on our own held-out multi-domain dev set (1,650 clips: 300 device-directed, 1,350 not), not a public benchmark; the default threshold was chosen on these clips. Set device_directed.threshold in full/config.json to trade recall for fewer false triggers:

threshold	false-positive rate	true-positive rate
0.50	4.4 %	96.0 %
0.70	3.7 %	93.7 %
0.85 (default)	2.3 %	90.7 %
0.95	1.3 %	86.3 %

Hardware and latency

Measured on a shared x86 server (4 CPU cores, torch.set_num_threads(4)), 16 kHz English audio.

backbone	mode	real-time factor (lower is faster)	peak RAM	load time
Arc Mini	whole file (`predict`, beam-4 transcript, all heads)	0.26-0.40	about 1.0 GB	about 3 s
Arc Mini	live stream, partial transcripts off (`partials=False`)	0.9 (100 ms chunk p50 62 ms)	about 1.6 GB
Arc Mini	live stream with partial transcripts every 0.4 s	1.4 (needs more than 4 cores; use `partial_every_s=1.0` or `partials=False` on small CPUs)	about 1.6 GB
Arc Transcriber	whole file, CPU (fp32)	0.9	about 3.5-4.3 GB	about 8 s (+ one-time 2.5 GB download)
Arc Transcriber	GPU (fp16 encoder)	not measured yet

The Arc Mini download is about 71 MB (4-bit packed weights; about 252 MB as float32). Weights are unpacked to float32 in memory at load time.

Outputs

predict() returns one dict, and stream().feed() returns the new records of the same kinds:

key	content
`transcript`	utterances `{start, end, text, words: [{text, start, end, tag}], tags: [{tag, start, end, text}], device_directed: {p, directed}}`
`names`	one per name mention: `heard`, `tag` (person / team / organization / place / ...), `entity` (your list's spelling) or null, `state` (`linked` / `not_in_list` / `abstain`), `start`, `end`, `via`
`numbers`	`heard`, `kind` (score, clock, time_of_day, date, duration, money, percent, ordinal, count, stat, measure, ...), `value`, `value2`, `unit`, `start`, `end`
`speakers`, `diarization`	per-speaker role and tags; `{speaker, start, end}` segments
`utterances`, `segments`, `spans`, `events`	per-utterance acts / intents; segment labels; word-span tags; instant events (speaker change, ...)
`audio_events`	`{label, start, end, p, status}` sound / channel events (see below)
`device_directed` (stream)	`{start, end, p, directed}` per utterance
`bio_events`	cough / throat clear / breath
`frames` (`return_frames=True`)	per-100 ms probabilities of every tag and event

Inline tag classes of the transcript decoder: ENTITY_PERSON TEAM ORG PLACE WORK EVENT LEGAL GAME MAP LAW PRODUCT TERM, NUMBER and its kinds (CLOCK COUNT DATE DURATION FIELDPOS ID JERSEY MEASURE MONEY ODDS ORDINAL PERCENT REF SCORE STAT TIME), and CONTACT_PHONE EMAIL URL ADDRESS (contact spans are tagged in the transcript only).

Event labels and their status

Events come from one head that reads the same audio features as the rest of Arc. Each label has a status:

status	labels	default
stable	`scene.silence` (Mini)	on
beta	`meta.channel.telephone`, `meta.channel.narrowband`, `meta.degraded_audio`, `meta.clipping` (Mini; on Arc Transcriber `scene.silence` is beta and `meta.clipping` experimental)	on
experimental	every other label (music, laughter, applause, cheer, siren, alarm, typing, cough, room size, SNR, safety labels, ...)	off; `events="all"` or `--events all`

Clip-level F1 of Arc Mini on a held-out event evaluation set (thresholds fitted on a separate half of it). Arc Transcriber was not scored on this set with its shipped thresholds.

label	Arc Mini F1
scene.silence	0.86
meta.channel.telephone	0.96
meta.channel.narrowband	0.96
meta.degraded_audio	0.73
meta.clipping	0.73

Limitations

English only. Other languages are transcribed poorly or not at all.
Events are mostly experimental. Only the labels marked stable / beta above are on by default. Experimental labels are often wrong on real audio. On Arc Transcriber the safety labels catch only 10 to 14 % of events at their shipped thresholds, scene.crying is not detected reliably, and meta.overlap is effectively off (threshold 0.999).
Names are hardest in meetings and assistant commands. Names in meetings and in short assistant requests are the weakest category; supply a name list or context terms when you can.
Arc Transcriber (full): its transcript and names are better than Arc Mini's, but its speaker roles and events are weaker (sports speaker roles: 75 % correct per voice vs 96 % for Arc Mini on the same windows; use Arc Mini when roles matter most). Its streaming mode computes Arc features in 10 s chunks, so tags and links arrive later than on Arc Mini; whole-file predict() uses 30 s chunks.
Speaker-change detection is modest (F1 about 0.43 on Arc Transcriber, from 0.16 to 0.66 depending on content).
Device-directed is beta on Arc Mini and experimental on Arc Transcriber; short utterances (< 1.5 s) have the most false alarms (about 21 % of non-directed clips under 1.5 s are flagged by Arc Transcriber).
Word timings on Arc Transcriber come from 80 ms encoder frames and are coarser than on Arc Mini.
External ASR words (--asr deepgram|verbit): Arc reads the words of these services as an optional transcript input. They are grouped into utterances with the same audio-based rule as the built-in transcript.
The model can produce wrong names, numbers and tags. Do not use it for decisions about people without human review.

Weights and files

mini/model.q4.safetensors (Arc), mini/moonshine-streaming-tiny/model.q4.safetensors (speech encoder + transcript decoder) and full/decoder/model.q4.safetensors are stored as 4-bit codes with per-group scales (group 32). arc_audio unpacks them at load time to exactly the values the model was evaluated with (no accuracy change). The remaining tensors are float32 / float16.
mini/heads.safetensors: event and device-directed heads. full/adapters.safetensors: Arc Transcriber's adapters and heads.
mini/model.q4.safetensors keeps one float16 table (word.tok_E, 21 MB) that is not on the 4-bit grid; it is a different table from the speech decoder's embedding (checked), so it cannot be shared without changing outputs.
MANIFEST.sha256 lists the SHA-256 of every file in this repository (sha256sum -c MANIFEST.sha256 in a full download).
Porting to MLX / Core ML / ONNX Runtime / ExecuTorch / TensorRT: see docs/DEPLOYMENT.md and docs/WEIGHTS_FORMAT.md in the GitHub repository, with golden reference outputs (tests/golden/) to check an export against (tests/golden/full.json matches Arc Transcriber, tests/golden/mini.json Arc Mini).
The NVIDIA Parakeet-TDT 0.6B v2 encoder is not included; the package downloads nvidia/parakeet-tdt-0.6b-v2 from Hugging Face on first use (pinned) and reads only its encoder weights. NeMo is not needed.

Licence and attributions

Arc code and Arc weights in this repository: CC BY-NC 4.0 plus the Whissle terms in LICENSE, non-commercial use only. See also NOTICE.
Commercial use (in or with a product or service, paid or hosted services, business use, or commercial use of outputs) requires a separate written licence from Whissle Inc.: contact ksingla@whissle.ai.
Whissle Inc. owns Arc and keeps all rights not expressly granted. The public licence does not limit Whissle Inc.'s own use of Arc or its right to license Arc, including later versions and derived models, on other terms. No patent or trademark rights are granted; "Whissle", "Whissle Arc", "Arc Mini" and "Arc Transcriber" are trademarks of Whissle Inc.
Arc is provided as is, without warranty. You are responsible for your outputs and for the rights and consents needed for the audio you process.
mini/moonshine-streaming-tiny/ and full/decoder/ are modified versions of Moonshine Streaming tiny by Useful Sensors, Inc. (dba Moonshine AI), MIT License; the licence and copyright notice are kept in those folders.
Arc Transcriber (full) uses NVIDIA Parakeet-TDT 0.6B v2, CC-BY-4.0, Copyright NVIDIA Corporation. It is downloaded from NVIDIA's repository at run time and is not modified or redistributed here; the adapters in full/adapters.safetensors read its encoder outputs.

Citation

@misc{whissle2026arc,
  title  = {Arc: an all-in-one streaming audio model},
  author = {{Whissle Inc.}},
  year   = {2026},
  note   = {Arc v1: Arc Mini and Arc Transcriber},
  url    = {https://huggingface.co/WhissleAI/arc-v1.1}
}

Downloads last month: -; Downloads are not tracked for this model. How to track

Model tree for WhissleAI/arc-v1.1

Base model

moonshine-ai/moonshine-streaming-tiny

Finetuned

(2)

this model