You need to agree to share your Hugging Face information to access this model

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

Arc v1.1 is released for non-commercial use under CC BY-NC 4.0. Commercial use requires a separate licence from WhissleAI (https://whissle.ai).

Arc v1.1 (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.

This repository holds two models built on the same Arc design. 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. It will be published in this repository as a new revision.

Revisions: v1.1.1 (current; folders mini/ and full/). v1.1.0 keeps the same weights under the earlier folder names edge/ and server/, so installs pinned to v1.1.0 keep working.

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

Quick start

pip install "arc-transcriber @ git+https://github.com/WhissleAI/arc_transcriber@v1.1.1"
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)          # or 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).

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, ...)	off; `events="all"` or `--events all`

Clip-level F1 on a held-out event evaluation set (thresholds fitted on a separate half of it):

label	Arc Mini F1	Arc Transcriber F1
scene.silence	0.86	0.71
meta.channel.telephone	0.96	0.68
meta.channel.narrowband	0.96	0.77
meta.degraded_audio	0.73	0.62
meta.clipping	0.73	0.21

Results

All numbers below were measured by us with one shared protocol for every system. 95% confidence intervals are paired bootstrap intervals over test items.

Comparisons with other models (word error rate on public test sets vs Parakeet-TDT, Whisper large-v3-turbo / small / base and Moonshine; names and numbers on Earnings-21; diarization on AMI) are being computed and will be added to this card shortly.

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

inline span F1 (overlap)	Arc v1 (previous release)	Arc Mini	Arc Transcriber
names (3637 gold spans)	62.2	67.8	76.4
numbers (2630 gold spans)	72.4	77.1	85.0

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

Spoken language understanding

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

269 test utterances; majority-class accuracy 6.3.

system	approach	accuracy	macro-F1
Arc Mini (on-device, streaming)	one model, from audio (streaming read-out)	46.5 [42.7, 48.4]	36.0
Arc Transcriber (Parakeet backbone)	one model, from audio (streaming read-out)	48.3 [42.7, 53.8]	41.3
Arc v1 (previous release)	one model, from audio (streaming read-out)	48.0 [44.9, 49.5]	36.0
reference transcript	text classifier on the transcript (upper bound)	82.9 [77.5, 87.1]	77.1

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

Hardware and latency

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

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.

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.
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): today its speaker roles and events are weaker than Arc Mini's, while its transcript and names are better. A retrained version is planned; it will be published here as a new revision, and the package will pick it up with a version bump. 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.
Device-directed is beta on Arc Mini and experimental on Arc Transcriber; short utterances (< 1.5 s) have the most false alarms.
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.
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.
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 revision) 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 (non-commercial). Commercial use requires a separate licence from WhissleAI (https://whissle.ai). See LICENSE and NOTICE.
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 v1.1: an all-in-one streaming audio model},
  author = {WhissleAI},
  year   = {2026},
  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