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 your Tycho entry.
  • 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_feature
  • heard: the words in spoken form, e.g. apollo twelve
  • entity: your list entry's name, e.g. Apollo 12
  • state: one of
    • linked: act on entity
    • abstain: ambiguous or generic, so ask the user
    • not_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.

Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
This model isn't deployed by any Inference Provider. ๐Ÿ™‹ Ask for provider support

Model tree for WhissleAI/arc-transcriber-space