Earlybird by sahilmahendrakar

Earlybird by sahilmahendrakar

Turns speech into text on a device and predicts each word before the speaker finishes it, scoring every word. A 16.8 MB English model for voice agents and live captions.

Made by sahilmahendrakar on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Earlybird is a 16.8 MB speech-to-text model that runs on a device. It shows each word before the speaker has finished saying it, and it scores every word. On audiobook speech, a typical word appears correctly 90 ms before it ends, while other released streaming models land 90 to 400 ms after.

Who it suits: It suits developers who build voice agents or live captions and want words early, on a small English model.

Title: Who might use it
Industry | Who uses it | How they use it | Example
Voice agents | Developers | Start a search or plan a reply while the person is still talking | Fetching a record before the sentence ends
Accessibility | Caption teams | Show words as they are spoken, each with a score | Live captions that fill in ahead of the speaker
On-device apps | Mobile and desktop developers | Run speech-to-text locally in a tiny model | A dictation feature that works on one CPU thread
Speech research | ASR researchers | Study early word prediction against latency and error rate | Comparing it with Moonshine Tiny, Whistle and Whisper base

Anyone who needs the lowest word error rate can skip it, because Whisper base makes fewer errors, though it is roughly nine times larger.

Where to use it:

• Python with transformers 5 or newer, torch and soundfile
• The command line: a script runs a recording or plays it live
• A live microphone feed: send 16 kHz mono audio in chunks
• Windows, macOS or Linux: on a single CPU thread it processes audio roughly two times faster than playback
• A demo Space on Hugging Face that the card points to

Title: Jobs it does
Use case | Who | What they get back
Transcribe a file | Developers | The text of a recording
Live transcription | Voice agent builders | An update every 80 ms with the words so far and a guess of the next two
Word scoring | Product teams | A score for each word, including the one still being spoken

How to set it up: You need these first:

• Python on Windows, macOS or Linux
• The torch, transformers (version 5 or newer), soundfile and huggingface_hub packages
• Recordings or live input converted to 16 kHz mono, then passed in 80 ms steps

1. Install the packages with pip.
2. Fetch earlybird.py too, because it is the file that loads the custom 4-bit weights.

pip install torch "transformers>=5" soundfile huggingface_hub
hf download sahilmahendrakar/Earlybird-29M earlybird.py --local-dir .

How to use it: Load the model from Python, then transcribe a file or feed live audio in chunks of any size. Each live update carries the text, the words and the guess.

from earlybird import Earlybird

eb = Earlybird.from_pretrained("sahilmahendrakar/Earlybird-29M")
print(eb.transcribe("speech.wav"))

# Live: feed 16 kHz mono float32 audio in chunks of any size
stream = eb.stream()
for chunk in mic_chunks:
    for u in stream.feed(chunk):          # one update per 80 ms of audio
        print(u.text, u.words, u.guess)   # words/guess: [(word, confidence), ...]
print(stream.finish().text)

From the command line, run the script on a recording. Add the live flag to play it at real-time speed.

python earlybird.py speech.wav

Example: You run the command line script on a recording called speech.wav. It prints the transcript. With the live flag, you watch updates appear while the recording plays, each showing the words so far and a guess of the next two.

For newcomers and experts: If you are new to this, think of it as captions that run slightly ahead of the speaker. Run the script on one short WAV file first, then try the live flag.

If you work in the field, it was tuned from Moonshine Tiny on audio cut at random points, even mid-word. It learns to write every word heard so far plus a guess of the next two. The author trimmed the vocabulary to the 19,007 tokens English speech uses, which gives 29M parameters, then quantized to 4 bits. Word scores come from raw token probabilities. The card says a word the model rates at 90% or more before it ends is right 91 to 96 percent of the time.

Audio arrives in 80 ms steps
The model writes the words heard so far
It adds a guess of the next two words
Every word gets a score

Good to know: The card compares median word latency, where a negative number means the word appeared before the speaker finished it.

Title: Median word latency on audiobooks in ms
Earlybird: -90 ms
Whisper base: 90 ms
Moonshine Tiny: 270 ms
Whistle: 400 ms

Title: Size and mean word error rate on 8 Open ASR sets
Model | Size | Mean word error rate
Whisper base | about 145 MB | 9.7%
Whistle | 16.9 MB | 12.2%
Earlybird | 16.8 MB | 12.6%
Moonshine Tiny | 45 MB | 14.4%

• License: mit
• Cost to run: none named
• Data it reaches: the audio you feed it, from a file or a live microphone
• Not for: non-English speech, since the model record lists English only

On Hugging Face, 13 November 2026

• Task: automatic speech recognition
• Library: transformers
• Downloads in the last 30 days: 89
• Likes: 24
• License: mit
• Languages: en
• Based on: moonshine-ai/moonshine-streaming-tiny
• Tags: transformers, moonshine_streaming, automatic-speech-recognition, speech-recognition, streaming, on-device, low-latency, 4-bit

Links

• Model: https://huggingface.co/sahilmahendrakar/Earlybird-29M
• Files: https://huggingface.co/sahilmahendrakar/Earlybird-29M/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download sahilmahendrakar/Earlybird-29M

Then follow the usage in its model card. Nothing in this kit runs by itself.