Arc Transcriber Space
Arc Transcriber Space is a streaming English speech model for space and Moon-exploration apps. In a single pass it gives:
- Transcript words, from a streaming FastConformer encoder with an RNNT decoder.
- Inline entity tags on the words: lunar features, sites, celestial bodies, spacecraft, missions, crew, numbers and more. Each tag is checked by a span head.
- Name linking to the app's own list (
names), so "show me tycho" returns yourTychoentry. - Long context: a names list, previous text and session memory.
- Audio events and device-directed speech.
- Room read-outs per utterance and per 80 ms frame: utterance act (question / command / confirmation / chatter / statement), end of turn, the app's own playback leaking into the microphone (sharper when you pass the playback audio as a reference), other loudspeaker speech, live speech and room tone. Two read-outs are BETA: the addressee (device / other person / reading aloud) and kids safety. See Room read-outs.
The encoder is an int8 ONNX graph (cache-aware streaming, 560 ms chunks). It runs on a CPU.
Results
Final numbers from the Arc Audio report, which has the full details: how the test sets were built, how leaks were removed, and per-tag scores.
Test data. The main benchmark is a NASA speech corpus collected by Team Outpost Luna from NASA public audio (Artemis audio and the podcasts Houston We Have a Podcast, Small Steps, Giant Leaps and Curious Universe). The test sets are whole held-out parts: 19 podcast episodes (12.8 h, 10,410 segments) and 15 Artemis recordings (1,141 utterances), none of which, nor any overlapping episode, was used to build the model. Every test set is scored in full.
Word error rate
Streaming, against the NVIDIA FastConformer this model started from
(nvidia/stt_en_fastconformer_hybrid_large_streaming_multi). Both models run streaming with the full-precision encoder and
are scored with the same text normalisation. The last column is the app's own path: the int8 ONNX encoder on a CPU through
arc_audio, with a names list (own names plus 20 similar-sounding decoys) on the Artemis, Apollo and space-question sets.
Lower is better.
| Test set | Size | NVIDIA base | Arc Transcriber Space | App path (int8, CPU) |
|---|---|---|---|---|
| NASA speech corpus (held out) | ||||
| Houston We Have a Podcast | 11 episodes | 10.0% | 6.3% | |
| Small Steps, Giant Leaps | 5 episodes | 9.7% | 5.6% | |
| Curious Universe | 3 episodes | 6.0% | 4.0% | |
| All podcast parts | 19 episodes, 12.8 h | 9.7% | 6.1% | 5.8% (2,000-segment sample) |
| Artemis audio | 1,141 utterances | 28.5% | 12.2% | 12.3% |
| Other test sets | ||||
| Apollo mission audio | 500 utterances | 35.5% | 15.2% | 15.7% |
| Open read speech (children's corpus) | 300 utterances | 42.0% | 17.4% | 18.0% |
| Space questions (synthetic speech) | 300 utterances | 48.1% | 7.8% | 4.7% |
| Common Voice 17 English | 2,000 clips | 12.6% | 14.9% | 14.9% |
| CREMA-D (acted adult speech) | 600 clips | 3.7% | 1.9% | 2.0% |
On Common Voice the base model is better (12.6% vs 14.9%): tuning for space speech costs some everyday dictation. Every other test set improves.
Names: hearing and linking them
The app's own path: the int8 ONNX encoder on a CPU, full test sets. Each utterance gets a names list made of its own names plus 20 similar-sounding decoys. On sets with no names, any link is a false link. The base model cannot link names.
| Test set | Name recall | Names linked correctly | Linked to a wrong entry | Space-tag F1 |
|---|---|---|---|---|
| Artemis II crew audio (1,141 utterances) | 93.4% | 94.7% | 0.8% | 0.89 |
| Space questions, synthetic speech (300) | 83.3% | 91.4% | 0.5% | 0.83 |
| Open read speech, children's corpus (300) | โ | 0.67 false links per 100 utterances (no names in this set) | โ | โ |
| Apollo mission audio (500) | โ | 0.2 false links per 100 utterances (no gold names in this set) | โ | โ |
Inline tag precision / recall / F1 (gold tag count in brackets):
| Tag | Artemis II crew audio (1,141) | Space questions (300) |
|---|---|---|
| ENTITY_LUNAR | .89 / .88 / .88 (584) | .88 / .82 / .85 (124) |
| ENTITY_SPACECRAFT | .86 / 1 / .92 (6) | .83 / .83 / .83 (29) |
| ENTITY_MISSION | โ | .81 / .77 / .79 (43) |
| ENTITY_CELESTIAL | .92 / .97 / .94 (34) | 1 / 1 / 1 (2) |
| ENTITY_TERM | .85 / .83 / .84 (115) | .50 / .50 / .50 (2) |
| ENTITY_PERSON | .23 / .94 / .36 (47) | .14 / 1 / .25 (1) |
| NUMBER | .51 / .69 / .59 (162) | .58 / 1 / .74 (7) |
| NUMBER_PERCENT | 0 / 0 / 0 (5) | 1 / 1 / 1 (13) |
| NUMBER_TIME | .08 / .03 / .04 (36) | โ |
| NUMBER_MEASURE | 0 / 0 / 0 (14) | 0 / 0 / 0 (1) |
| All space name tags | .89 / .89 / .89 (624) | .86 / .81 / .83 (198) |
Weak spots: ENTITY_PERSON fires too often (low precision), and number kinds (time, measure) are rarely right. The four space name tags (lunar, spacecraft, mission, celestial), the ones linked to the app's names lists, are the strong ones.
Overlap with training. CREMA-D is test only. Common Voice is scored on its official test split; no test sentence is used to build the model. Open read speech uses the corpus's own split (train split only). The space questions and Apollo test utterances are held out. The NASA podcast and Artemis audio are split by whole episode or recording: the test episodes and recordings above never are in training.
Room read-outs
All numbers below are from the app's path (int8 ONNX encoder on a CPU, nft2/room.onnx) on held-out test sets (test
episodes, recordings and sentences are held out).
| Read-out | Test set | Result |
|---|---|---|
| App playback in the microphone, with the playback reference | Real laptop speaker-to-microphone recordings of app lines (164) | frame AUC 0.94, F1 0.89 |
| App playback, without reference | same | frame AUC 0.84, F1 0.78 |
| App playback, with reference | Simulated laptop echo of app lines, with and without a child talking (240) | frame AUC 0.97, F1 0.88 |
| App playback, without reference | same | frame AUC 0.95, F1 0.61 |
| Utterance act | Room talk, synthetic voices (240) | 65% accuracy |
| Utterance act | 1-3 word turns, synthetic voices (200) | 58% accuracy |
| Addressee (BETA) | Room talk, synthetic voices (240): to the device / to another person / reading aloud | 53% accuracy; device vs other person 79% (160); reading aloud is almost never detected |
| Kids safety (BETA) | Short child-voice turns, synthetic voices (300: 135 unsafe, 165 harmless but tricky) | flags 46% of unsafe turns; flags 20% of harmless ones |
BETA outputs. The addressee and kids-safety read-outs carry "beta": true in nft2/config.json (room.addressee,
room.safety) and in every result.
- Addressee is not yet reliable for room talk (people talking to each other near the device) or for reading aloud.
- Kids safety is not a safety system. On children's voices it misses more than half of unsafe turns in our tests and also marks some harmless ones; it has not been tested on recordings of real children. Never use it as the only check or for any safety-critical or child-protection decision. Keep your own safety checks, and treat this output as a hint only.
Other weak spots: the utterance act is often statement on very short turns ("go", "yes"). Synthetic text-to-speech voices
tend to read as playback or another person, so test the room read-outs with real voices.
Speed
On CPU with 4 threads, the encoder and RNNT run at about 0.13ร real time with a peak of about 2.3 GB RAM, model included. The room read-outs add one more encoder pass over each utterance.
Install
The code is in the arc_transcriber package; use the space extra.
pip install "arc-transcriber[space] @ git+https://github.com/WhissleAI/arc_transcriber"
A C library is also available (see c/README.md in the same repository). It uses the ONNX Runtime C API for the encoder:
git clone https://github.com/WhissleAI/arc_transcriber && cd arc_transcriber/c
make ARC_ORT=/path/to/onnxruntime # builds libarc + arc-nft2
Use
import soundfile as sf
from arc_audio import Arc
arc = Arc.from_pretrained("WhissleAI/arc-transcriber-space", backbone="nft2", device="cpu", threads=4)
NAMES = [ # what is on screen / in the current lesson, most relevant first
{"name": "Tycho", "kind": "lunar_feature"},
{"name": "Apollo 12", "kind": "mission"},
{"name": "Ocean of Storms", "kind": "lunar_feature", "aliases": ["Oceanus Procellarum"]},
{"name": "Orion", "kind": "spacecraft"},
{"name": "Artemis II", "kind": "mission", "aliases": ["Artemis 2"]},
]
wav, sr = sf.read("examples/samples/sample_2.wav", dtype="float32") # 16 kHz mono
out = arc.predict(wav, domain="assistant", transcript="nft2", names=NAMES)
print(out["transcript"][0]["text"]) # "Show me the Apollo twelve landing site in the ocean of storms"
for n in out["names"]:
print(n["heard"], "->", n["entity"], n["state"]) # "Apollo" -> "Apollo 12" linked ; "ocean of storms" -> "Ocean of Storms" linked
# streaming (microphone): feed 16 kHz float32 chunks, change the list at any time
s = arc.stream(domain="assistant", transcript="nft2", names=NAMES)
for chunk in mic_chunks(): # e.g. 100 ms each
for update in filter(None, [s.feed(chunk)]):
... # partial / final transcript, names, events
s.set_context(names=NEW_SCREEN_NAMES, previous_text="...")
final = s.flush()
With arc-transcriber 1.3.0 or later, each transcript utterance also has room (turn it off with room=False):
r = out["transcript"][0]["room"]
r["act"]["label"] # "command"
r["end_of_turn"], r["playback"] # end-of-turn probability; share of frames that are the app's own playback
r["addressee"], r["safety"] # BETA (each has "beta": True); read arc.room_notes() first
arc.room(wav, reference=tts_wav) # one turn, with the app's playback aligned sample for sample; adds 80 ms frame tracks
Each item in out["names"] has these fields:
tag: the entity type, e.g.entity.mention.lunar_featureheard: the words in spoken form, e.g.apollo twelveentity: your list entry'sname, e.g.Apollo 12state: one oflinked: act onentityabstain: ambiguous or generic, so ask the usernot_in_list: a name the user said that is not in your list
p: confidence
Names lists: read this before integrating
Linking compares normalized text:
- lower case;
- digits become spoken words:
Apollo 12โapollo twelve,1969โnineteen sixty nine; -becomes a space;- accented and other non-ASCII letters are dropped.
Rules for building lists:
- Always give a
kind. - Put the most relevant names first.
- Keep lists short.
- Add aliases for names that are not said the way they are written:
Artemis IIโ"Artemis 2",S-IVBโ"S 4 B". - Add ASCII aliases for non-ASCII names:
Schrรถdingerโ"Schrodinger".
The full guide is in NAMES_LISTS.md.
The transcript is in spoken form ("apollo twelve"). For display and routing, use names[i].entity, which is your
list's own spelling.
Notes
- Input is 16 kHz mono audio.
- The model is built not to transcribe the app's own spoken answers: text-to-speech playback leaking into the microphone. Synthetic TTS voices, especially female Kokoro-style voices, can therefore be partly or fully ignored. Test with real voices, not TTS. Real children's speech is transcribed normally.
- The
examples/samples/clips are synthetic speech made with Kokoro-82M (Apache-2.0). They contain no recording of a real person.
Licence
ยฉ 2026 Whissle Inc. The model weights are licensed under CC BY-NC 4.0 together with the Whissle terms in LICENSE, for non-commercial use only. Commercial licences: ksingla@whissle.ai, https://whissle.ai. Third-party components are listed in NOTICE:
- a modified NVIDIA FastConformer (
nvidia/stt_en_fastconformer_hybrid_large_streaming_multi, CC-BY-4.0); - a modified Moonshine Streaming decoder (MIT; its licence is kept in
nft2/decoder/LICENSE).
The model files are listed with their SHA-256 hashes in nft2/SHA256SUMS (sha256sum -c nft2/SHA256SUMS).
This model is not affiliated with or endorsed by NASA or NVIDIA.