---
title: "Backchannel Cue 32M"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/aa99a1e5-7344-483a-8c16-31f4f4116b9b"
updated: "2026-11-12"
---

# Backchannel Cue 32M

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

Decides when a voice assistant should drop in a small listening sound such as mhm or oh no while the user is still talking, from the words so far. Text only, and it answers in about 5 ms on a CPU.

Backchannel Cue 32M 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 KoljaB

## About

### What it is

This model gives a voice assistant the habit of listening out loud. Humans murmur small signals like mhm or oh no while someone else talks, and assistants that wait in silence feel cold. You pass in what the user has said so far at a pause, and the model says whether a listener would react and how. Because it needs only a CPU, calling it at each pause costs little and needs no LLM.

### Who it suits

It suits developers who build spoken assistants and want them to sound attentive during a user's turn.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Voice assistants | Developers of spoken assistants | Check each pause for a fitting listening cue | Respond with a sympathy cue when a user mentions a parent falling ill |
| Phone and call bots | Teams that build voice bots | Keep callers engaged while they speak | Say mhm after a long clause |
| Dialogue research | Researchers of turn-taking | Study when people respond and in which words | Read the gate AUC results and the training notes |

If your product has no voice, or you need replies and not small cues, you can skip it.

### Where to use it

- Python projects that use onnxruntime
- Voice pipelines that produce a live transcript
- Machines without a GPU, since it runs on a CPU
- Windows, macOS or Linux with Python, to download the files

| Use case | Who | What they get back |
| --- | --- | --- |
| Listening cues | Voice app developers | A cue probability, fitting reactions and likely wording |
| Mood checks | Teams that care about tone | A mood label of neutral, bad, good or funny |
| Ask-back prompts | Assistant builders | An echo question that fits a sentence left hanging |

### How to set it up

What you need first:

- Python with onnxruntime, tokenizers, numpy and huggingface\_hub
- About 129 MB of space for the ONNX model
- A live transcript from your speech recognizer

1. Download the repository, which includes example.py.
2. Install the Python packages.
3. Run example.py to see a complete policy you can copy.

```bash
pip install -U huggingface_hub
hf download KoljaB/backchannel-cue-32m
```

```bash
pip install onnxruntime tokenizers numpy huggingface_hub
python example.py
```

### How to use it

Call the decide function from example.py with the transcript of the current turn, about 0.45 seconds into a pause. It returns the text to say, or nothing when staying quiet is better. If you can, speak the cue from a pre-recorded clip, since live generation tends to arrive late.

```python
from example import decide

decide("my dad got really sick last week")   # e.g. "Oh no."
decide("i wanted to tell you about")         # "About what?"
decide("what time is it")                    # usually None: stay quiet
```

| Tool | What it does |
| --- | --- |
| decide | Turns the current turn's words into a cue, or into silence |
| example.py | A complete policy you can copy, including the rules below |
| clean | Prepares the text as lowercase words without punctuation |
| config.json | Lists every label and maps each reaction to its wording |

### Example

You pass a sentence about a parent falling ill. The model returns a sympathy cue such as oh no. For a plain question about the time, it usually returns nothing, so the assistant stays quiet.

### For newcomers and experts

A good first try is to run example.py and feed it a few sentences, some sad and some neutral. Watch which ones get a cue and which stay silent.

For experts, the model builds on the ettin-encoder-32m encoder and returns a gate probability, scores for each reaction type, a mood, 61 wording classes and an echo score. The card's rules matter as much as the scores. They set a lower cue bar mid-sentence, hold back laughs and praise when the mood looks bad, and space cues at least 6 seconds apart. Send only the current turn, newest 30 words.

You send the words of the current turn → The model scores gate, reactions, mood and wording → Your rules decide whether to speak → You play a pre-rendered cue, or stay quiet

### Good to know

Time per call on one CPU thread

| Label | Value |
| --- | --- |
| Short text | 5 ms |
| 40 words | 12 ms |

Reported checks

| Check | Result |
| --- | --- |
| Gate AUC, held-out corpus pauses | 0.733 |
| Mood accuracy, written dev set | 86% |
| New sad sentences read as bad | 12 of 12 |
| Echoes at 0.7, good ones fired | 14 of 14 |

- Input: only the words of the current turn plus a few counters, with no audio.
- Language: English.
- Rules: the raw scores are not a finished policy, and example.py applies the first three of the card's rules.
- Training: the repository contains weights and no training data. Teacher labels were produced partly by a locally run Qwen model and partly by OpenAI models.
- License: mit
- Cost to run: no API key or paid service named.
- Data it reaches: it downloads files from Hugging Face and reads only the transcript text you give it.
- Not for: replacing your assistant's reply once the user has clearly finished their turn.

## README

````markdown
# Backchannel Cue 32M

Decides when a voice assistant should drop in a small listening sound such as mhm or oh no while the user is still talking, from the words so far. Text only, and it answers in about 5 ms on a CPU.

Made by KoljaB 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: This model gives a voice assistant the habit of listening out loud. Humans murmur small signals like mhm or oh no while someone else talks, and assistants that wait in silence feel cold. You pass in what the user has said so far at a pause, and the model says whether a listener would react and how. Because it needs only a CPU, calling it at each pause costs little and needs no LLM.

Who it suits: It suits developers who build spoken assistants and want them to sound attentive during a user's turn.

```table
Industry | Who uses it | How they use it | Example
Voice assistants | Developers of spoken assistants | Check each pause for a fitting listening cue | Respond with a sympathy cue when a user mentions a parent falling ill
Phone and call bots | Teams that build voice bots | Keep callers engaged while they speak | Say mhm after a long clause
Dialogue research | Researchers of turn-taking | Study when people respond and in which words | Read the gate AUC results and the training notes
```

If your product has no voice, or you need replies and not small cues, you can skip it.

Where to use it:

- Python projects that use onnxruntime
- Voice pipelines that produce a live transcript
- Machines without a GPU, since it runs on a CPU
- Windows, macOS or Linux with Python, to download the files

```table
Use case | Who | What they get back
Listening cues | Voice app developers | A cue probability, fitting reactions and likely wording
Mood checks | Teams that care about tone | A mood label of neutral, bad, good or funny
Ask-back prompts | Assistant builders | An echo question that fits a sentence left hanging
```

How to set it up: What you need first:

- Python with onnxruntime, tokenizers, numpy and huggingface_hub
- About 129 MB of space for the ONNX model
- A live transcript from your speech recognizer

1. Download the repository, which includes example.py.
2. Install the Python packages.
3. Run example.py to see a complete policy you can copy.

```bash
pip install -U huggingface_hub
hf download KoljaB/backchannel-cue-32m
```

```bash
pip install onnxruntime tokenizers numpy huggingface_hub
python example.py
```

How to use it: Call the decide function from example.py with the transcript of the current turn, about 0.45 seconds into a pause. It returns the text to say, or nothing when staying quiet is better. If you can, speak the cue from a pre-recorded clip, since live generation tends to arrive late.

```python
from example import decide

decide("my dad got really sick last week")   # e.g. "Oh no."
decide("i wanted to tell you about")         # "About what?"
decide("what time is it")                    # usually None: stay quiet
```

```table
Tool | What it does
decide | Turns the current turn's words into a cue, or into silence
example.py | A complete policy you can copy, including the rules below
clean | Prepares the text as lowercase words without punctuation
config.json | Lists every label and maps each reaction to its wording
```

Example: You pass a sentence about a parent falling ill. The model returns a sympathy cue such as oh no. For a plain question about the time, it usually returns nothing, so the assistant stays quiet.

For newcomers and experts: A good first try is to run example.py and feed it a few sentences, some sad and some neutral. Watch which ones get a cue and which stay silent.

For experts, the model builds on the ettin-encoder-32m encoder and returns a gate probability, scores for each reaction type, a mood, 61 wording classes and an echo score. The card's rules matter as much as the scores. They set a lower cue bar mid-sentence, hold back laughs and praise when the mood looks bad, and space cues at least 6 seconds apart. Send only the current turn, newest 30 words.

```flow
You send the words of the current turn
The model scores gate, reactions, mood and wording
Your rules decide whether to speak
You play a pre-rendered cue, or stay quiet
```

Good to know:

```chart
Title: Time per call on one CPU thread
Short text: 5 ms
40 words: 12 ms
```

```table
Title: Reported checks
Check | Result
Gate AUC, held-out corpus pauses | 0.733
Mood accuracy, written dev set | 86%
New sad sentences read as bad | 12 of 12
Echoes at 0.7, good ones fired | 14 of 14
```

- Input: only the words of the current turn plus a few counters, with no audio.
- Language: English.
- Rules: the raw scores are not a finished policy, and example.py applies the first three of the card's rules.
- Training: the repository contains weights and no training data. Teacher labels were produced partly by a locally run Qwen model and partly by OpenAI models.
- License: mit
- Cost to run: no API key or paid service named.
- Data it reaches: it downloads files from Hugging Face and reads only the transcript text you give it.
- Not for: replacing your assistant's reply once the user has clearly finished their turn.

## On Hugging Face, 13 November 2026

- Task: text classification
- Library: onnxruntime
- Downloads in the last 30 days: 114
- Likes: 27
- License: mit
- Languages: en
- Based on: jhu-clsp/ettin-encoder-32m
- Tags: onnxruntime, onnx, backchannel, voice-assistant, conversational-ai, text-classification

## Links

- Model: https://huggingface.co/KoljaB/backchannel-cue-32m
- Files: https://huggingface.co/KoljaB/backchannel-cue-32m/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download KoljaB/backchannel-cue-32m
```

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

[KoljaB/backchannel-cue-32m on Hugging Face](https://huggingface.co/KoljaB/backchannel-cue-32m)

## 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 |
| --- | --- | --- | --- | --- | --- |
| Backchannel Cue 32M (this page) | 114 | 27 | — | mit | 2026-11-02 |
| [Indic Multilingual Turn Detector](https://mindket.com/p/5f00495d-08d7-4589-865a-4a1efccb8c23) | 81 | 3 | 494M | apache-2.0 | 2026-11-07 |
| [Pipecat backchannel detector](https://mindket.com/p/a06dbcca-30d4-4948-baa5-b39206354c9e) | 0 | 17 | 961K | bsd-2-clause | 2026-10-28 |
| [ZeroTTS](https://mindket.com/p/97fb68f6-db3d-4745-9202-2956cafdf46f) | 8,091 | 54 | — | mit | 2026-10-31 |
| [RuView by ruv](https://mindket.com/p/07d0e4a5-fd96-4a4d-8d23-bd9c1bb45bef) | 69 | 37 | — | mit | 2026-10-09 |
| [deberta-v3-base-prompt-injection-v2](https://mindket.com/p/bbb131a8-e7e6-491b-b19e-25098c98a48d) | 476,298 | 129 | 184M | apache-2.0 | 2026-07-09 |

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

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Hacker News · mrkn1 · 2026-11-02](https://news.ycombinator.com/item?id=50338965): A 32M Model That Knows When to Say 'Oh No', 'Really?' Or Just Shut Up

## 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-02
- First published: 2026-11-01
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open KoljaB/backchannel-cue-32m on Hugging Face](https://huggingface.co/KoljaB/backchannel-cue-32m)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/aa99a1e5-7344-483a-8c16-31f4f4116b9b)
- [Its page on Mindket](https://mindket.com/p/aa99a1e5-7344-483a-8c16-31f4f4116b9b)
