---
title: "Earlybird by sahilmahendrakar"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/63374aaf-908f-49b3-9cfc-811cda44e66e"
updated: "2026-11-12"
---

# Earlybird by sahilmahendrakar

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Earlybird by sahilmahendrakar is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by sahilmahendrakar

## 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.

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

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.

```bash
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.

```python
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.

```bash
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.

Median word latency on audiobooks in ms

| Label | Value |
| --- | --- |
| Earlybird | -90 ms |
| Whisper base | 90 ms |
| Moonshine Tiny | 270 ms |
| Whistle | 400 ms |

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

## README

````markdown
# 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.

```table
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

```table
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.

```bash
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.

```python
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.

```bash
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.

```flow
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.

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

```table
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:

```sh
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.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[sahilmahendrakar/Earlybird-29M on Hugging Face](https://huggingface.co/sahilmahendrakar/Earlybird-29M)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Earlybird by sahilmahendrakar (this page) | 89 | 24 | — | mit | 2026-11-11 |
| [MOSS-Video-Preview-Real-Time-SFT](https://mindket.com/p/284469ea-b585-406e-b58d-ec446ae9bded) | 74 | 30 | 10.7B | apache-2.0 | 2026-08-04 |
| [Whistle](https://mindket.com/p/2a83a355-5760-461d-9833-a5d15efc8cc8) | 94,489 | 570 | — | apache-2.0 | 2026-11-05 |
| [phonon-31m-en](https://mindket.com/p/8936ffbe-babc-4766-b999-5315308551db) | 248,578 | 160 | 41.1M | apache-2.0 | 2026-10-22 |
| [parakeet-ultra](https://mindket.com/p/5647b30a-a58e-4b54-b4fc-18517ea9dde6) | 51,675 | 142 | 627M | cc-by-4.0 | 2026-09-23 |
| [Qwen3-ASR-1.7B GGUF](https://mindket.com/p/10bca442-bcbf-45b9-9c6c-930624df43f9) | 11,523 | 17 | 2.3B | apache-2.0 | 2026-08-02 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-11
- First published: 2026-11-07
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open sahilmahendrakar/Earlybird-29M on Hugging Face](https://huggingface.co/sahilmahendrakar/Earlybird-29M)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/63374aaf-908f-49b3-9cfc-811cda44e66e)
- [Its page on Mindket](https://mindket.com/p/63374aaf-908f-49b3-9cfc-811cda44e66e)
