Get Hunch-1 Home
This repository is publicly accessible, but you have to accept the conditions to access its files and content.
Free for non-commercial use (CC BY-NC 4.0), and access is immediate. For commercial use, answer Yes below and we will reply. Hugging Face shares your username and email address with us.
Log in or Sign Up to review the conditions and access this model content.

Hunch-1.1 Home understands the home commands people actually say, typed or spoken, on your own device, and learns a new one from three examples.
Try it in your browser Demo with voice Free for non-commercial use
Walk through a 3D house and type a command. Hunch-1.1 Home runs in your browser tab, and nothing you type leaves your device.
- 70.9% of people's own home commands fully right, up from 38.0% with 1.0. 474 real commands typed in public posts or said in public videos; fully right means both answers, what to do and what kind of thing.ΒΉ
- 24 more commands, two new actions (previous and announce) and "next" now listed, among them asking about the heating, setting lights and blinds to a level, opening doors and water valves, more or less time on a timer, skipping back a track and announcements.
- Learned from real sentences. 1,074 of them, from people's posts and videos and from Home Assistant's and device makers' example commands, beside 880 newly written examples.
- 21 ms typed and 87 ms spoken with the full-size model, on your own device. Offline, with nothing to pay per command; builds for phones, Macs and small boards from 165 MB.Β²
Run it on your own device: fill in the short form at the top of this page (access is immediate) and follow Run it: a download and four lines of Python.
ΒΉ More figures under What's new in 1.1 and, in full, under Technical details.
Β² Measured with version 1.0 on a MacBook M1 Pro; 1.1 runs the same encoder and voice files. 1.0's comparison with cloud models, decision models and open home systems is carried below, under How it compares and Against open systems.
What it does
Every home command gets two answers from Hunch, what to do and what kind of thing to do it to, and your app does the rest, for example a Home Assistant automation or your own code. Anything that isn't a home command gets "not for me", so your app can hand it to your assistant or another tool.
| You say | What to do | What kind of thing |
|---|---|---|
| turn on the kitchen lights | turn on | Lights |
| make the lights blue | set colour | Lights |
| what is the upstairs temperature | ask | Climate |
| get the hoover going | turn on | Other device |
| crank the music up | raise | Speakers & TVs |
| what's the capital of France? | not for me | none |
Everything it understands
What to do: turn on, turn off, set level, raise, lower, set colour, set temperature, lock, unlock, open, close, next, previous, announce, ask, add and remove. "Start" and "play" count as turn on; "stop", "pause" and "cancel" as turn off.
What kind of thing: Lights, Climate, Security, Speakers & TVs, Water, Scenes, Timers and alarms, Weather, Lists and Other device. Anything else is "not for me".
What's new in 1.1
1.1 is 1.0 with many more examples to match against, so it understands far more of the ways people phrase home commands.
- People's own commands: 70.9% fully right, against 38.0% with 1.0 (474 commands typed in public posts or said in public videos about home assistants).
- Where the new examples come from. 1,074 real sentences: commands people typed in public posts or said in public videos, Home Assistant's own example commands and device makers' example commands, with some sentences that only sound like a command, stored as "not for me". 880 more examples were newly written for this release.
- 24 new commands: asking about lights, heating, security, water and other devices; dimming lights to a level; setting blinds to a level; setting the temperature of water and of other devices; opening and closing doors and water valves; switching security and water on and off; next, previous and announce on speakers; more time, less time and stopping on timers and alarms; turning a scene off. Two actions are new, previous and announce, and "next", which 1.0's list carried with no command, now has commands.
- On the public benchmark, much as 1.0. On SLURP's test set, both answers right, 1.1 gets 95.3% of typed commands against 95.5% for 1.0. Spoken commands are a little below 1.0: 89.4% against 90.9%.
- It answers more readily, so it also acts on more sentences that only sound like a command (see Limits).
See it

Typed: "turn on the kitchen lights", answered Turn on, Lights. Spoken: a SLURP test recording of "turn off the porch light", answered Turn off, Lights straight from the sound, with no transcript.
Run it
Get access: fill in the short form at the top of this page (access is immediate), then sign in with hf auth login. The code needs Python 3.10 or newer; a Mac's own /usr/bin/python3 is 3.9.
pip install -U huggingface_hub && hf auth login
hf download xevall/hunch-1-home --revision v1.1 --local-dir hunch-1-home && cd hunch-1-home
pip install -r requirements.txt
from hunch_home import Hunch
hunch = Hunch.from_pretrained(".") # or "xevall/hunch-1-home", from any folder
print(hunch.answer_text("turn on the kitchen lights")) # {'action': 'turn on', 'kind': 'Lights', ...}
# hunch.answer_audio("command.wav") answers a recording the same way
More ways to run it
- From the command line:
python example.py "turn on the kitchen lights"in the downloaded folder. - Teach it a command from three examples, then ask:
from hunch_home import Hunch
hunch = Hunch.from_pretrained(".")
hunch.teach("feed the cat", action="turn on", kind="Other device", sentences=["feed the cat", "give the cat her dinner", "it's cat food time"])
print(hunch.answer_text("could you feed the cat")) # turn on, Other device
- The fastest typed route, the one behind the typed time at the top:
typed-full/of xevall/hunch-1-home-ONNX, the same model, which answers exactly asHunchdoes on every typed test sentence (same short access form).hunch_homeswitches ONNX Runtime's usage reports off; if you load the model with your own code, setORT_DISABLE_TELEMETRY=1yourself.
hf download xevall/hunch-1-home-ONNX --revision v1.1 --include "typed-full/*" "hunch_home/*" --local-dir hunch-1-home-ONNX
cd hunch-1-home-ONNX && pip install onnxruntime tokenizers numpy
python -c 'from hunch_home.fast import fast_typed; print(fast_typed(".").answer_text("turn on the kitchen lights"))'
- Smaller builds for phones, Macs and small boards (typed 165 to 276 MB, voice 278 to 434 MB), each with its own read-me; sizes under Builds for devices:
| Build | Runs on | Repository |
|---|---|---|
| ONNX | ONNX Runtime, on any computer | xevall/hunch-1-home-ONNX |
| Core ML | iPhone and Mac | xevall/hunch-1-home-CoreML |
| LiteRT | LiteRT and MediaPipe on phones | xevall/hunch-1-home-LiteRT |
| GGUF | GGUF runtimes | xevall/hunch-1-home-GGUF |
How it compares
Measured with version 1.0 and carried here as published on 1.0's page. 1.1 runs the same encoder and voice files; its own figures are under What's new in 1.1.

We sent the same 2,974 typed and 2,766 spoken commands from SLURP's test set, home commands and the rest, to cloud LLMs, cloud audio models and decision models, one request at a time, as a product would send them. Here, right means the command's label is right by SLURP's own labels, a different measure from the both-answers figures further down. Hunch reports its label for every command beside its two answers, so a command it answers "not for me" is still scored.
- Typed: 88.3% in 21 ms on a MacBook M1 Pro, offline, with nothing to pay per command. Of the nine other systems, two score more, Claude Fable 5.2 (89.7%, 1.4 points more) and Claude Opus 5.5 (88.4%, 0.1 points more), and the quickest of them, Claude Opus 5.5, takes 76 times as long (cloud times include the network). The other seven score less, among them all four decision models and the cloud LLMs Gemini 4 Carbon, GPT-6.1 Sol and Inkling.
- Spoken: 78.3% straight from the recording, in 87 ms on a MacBook M1 Pro, offline. Of the twelve other systems, six score more, by up to 8.0 points (ElevenLabs Scribe v2 then Claude Opus 5.5, 2.3 s a command, the network included), and six score less, the best of them GPT Realtime at 70.8%. Beside the best audio models, Gemini 4 Argon and Gemini 4 Carbon (85.2% and 85.1%, 3.8 s and 7.8 s), and transcribing with ElevenLabs Scribe v2 then Claude Opus 5.5 (86.3%, 2.3 s), Hunch is 26 to 90 times faster and 6.8 to 8.0 points less accurate (cloud times include the network). No system measured is both quicker and more accurate.


| System | Measured | Input | Label right (95% interval) | Time | Cost per 1,000 | Size | Where it runs |
|---|---|---|---|---|---|---|---|
| Hunch-1 Home 1.0 | 15 Nov | typed | 88.3% (87.1 to 89.4) | 21 ms | none | 1,117 MB | your device |
| Claude Fable 5.2 | 12 to 13 Nov | typed | 89.7% (88.7 to 90.7) | 2.7 s | $7.40 | β | cloud, Vercel AI Gateway |
| Claude Opus 5.5 | 9 to 10 Nov | typed | 88.4% (87.3 to 89.4) | 1.6 s | $3.98 | β | cloud, direct |
| Gemini 4 Carbon | 12 to 13 Nov | typed | 87.8% (86.7 to 88.8) | 9.4 s | $14.29 | β | cloud, Vercel AI Gateway |
| GPT-6.1 Sol | 9 to 10 Nov | typed | 86.2% (85.2 to 87.3) | 1.6 s | $1.33 | β | cloud, direct |
| Clef-omni | 6 Nov | typed | 84.9% (83.8 to 86.0) | 472 ms | $0.29 | β | cloud, OpenRouter |
| Gemini Decision 1 | 12 to 13 Nov | typed | 68.4% (67.1 to 69.6) | 524 ms | $0.09 | β | cloud, Vercel AI Gateway |
| Hunch-1 Home 1.0 | 15 Nov | spoken | 78.3% (76.8 to 79.8) | 87 ms | none | 1,770 MB | your device |
| ElevenLabs Scribe v2 then Claude Opus 5.5 | 9 to 10 Nov | spoken | 86.3% (85.2 to 87.5) | 2.3 s | $4.42 | β | cloud, direct |
| Gemini 4 Argon | 8 Nov | spoken | 85.2% (84.1 to 86.5) | 3.8 s | $1.97 | β | cloud, OpenRouter |
| Clef-omni | 7 Nov | spoken | 82.4% (81.2 to 83.7) | 385 ms | $0.29 | β | cloud, OpenRouter |
| GPT Realtime | 8 Nov | spoken | 70.8% (69.4 to 72.3) | 1.1 s | $5.04 | β | cloud, direct |
| ElevenLabs Scribe v2 then OpenAI Decisions | 8 Nov | spoken | 58.3% (56.8 to 59.8) | 947 ms | $0.41 | β | cloud, direct |
| Gemini Decision 1 | 12 to 13 Nov | spoken | 52.6% (51.0 to 54.1) | 872 ms | $0.10 | β | cloud, OpenRouter |
| ElevenLabs agent (on a 300-recording sample)β | 8 Nov | spoken | 65.7% (61.3 to 70.0) | 435 ms | $18.09 | β | cloud, direct |
Dates are 2026. Size counts a local model's files, its tokenizer included; cloud systems publish no size ("β"). β ElevenLabs' voice agent was measured on a fixed random 300 of the 2,766 recordings, not the full set (the 27 it gave no answer to count as wrong), so it is not on the charts; on the same 300, Gemini 4 Argon scored 87.7% (85.2% on all 2,766), so the sample is not harder than the full set.
Every system in the table, with its version, and how the figures were counted
| System (version) | Measured | Input | Label right (95% interval) | Time | Cost per 1,000 | Size | Where it runs |
|---|---|---|---|---|---|---|---|
| Hunch-1 Home (version 1.0, full size) | 15 Nov | typed | 88.3% (87.1 to 89.4) | 21 ms | none | 1,117 MB | your device |
| Claude Fable 5.2 (anthropic/claude-fable-5.2) | 12 to 13 Nov | typed | 89.7% (88.7 to 90.7) | 2.7 s | $7.40 | β | cloud, Vercel AI Gateway |
| Claude Opus 5.5 (claude-opus-5-5, effort high) | 9 to 10 Nov | typed | 88.4% (87.3 to 89.4) | 1.6 s | $3.98 | β | cloud, direct |
| Gemini 4 Carbon (google/gemini-4-carbon) | 12 to 13 Nov | typed | 87.8% (86.7 to 88.8) | 9.4 s | $14.29 | β | cloud, Vercel AI Gateway |
| GPT-6.1 Sol (gpt-6.1-sol, reasoning effort high) | 9 to 10 Nov | typed | 86.2% (85.2 to 87.3) | 1.6 s | $1.33 | β | cloud, direct |
| Inkling (thinkingmachines/inkling) | 12 to 13 Nov | typed | 75.8% (74.5 to 77.1) | 1.6 s | $1.43 | β | cloud, Vercel AI Gateway |
| Clef-omni (Cloudflare Clef-omni) | 6 Nov | typed | 84.9% (83.8 to 86.0) | 472 ms | $0.29 | β | cloud, OpenRouter |
| Jev (TypeSafe Jev) | 6 Nov | typed | 69.9% (68.6 to 71.3) | 331 ms | $0.07 | β | cloud, direct |
| Gemini Decision 1 (google/gemini-decision-1) | 12 to 13 Nov | typed | 68.4% (67.1 to 69.6) | 524 ms | $0.09 | β | cloud, Vercel AI Gateway |
| OpenAI Decisions (OpenAI Decisions API) | 6 Nov | typed | 61.6% (60.2 to 63.0) | 379 ms | $0.09 | β | cloud, direct |
| Hunch-1 Home (version 1.0, full size) | 15 Nov | spoken | 78.3% (76.8 to 79.8) | 87 ms | none | 1,770 MB | your device |
| ElevenLabs Scribe v2 then Claude Opus 5.5 (Scribe v2; claude-opus-5-5, effort high) | Scribe 7 Nov; Claude 9 to 10 Nov | spoken | 86.3% (85.2 to 87.5) | 2.3 s | $4.42 | β | cloud, direct |
| ElevenLabs Scribe v2 then GPT-6.1 Sol (Scribe v2; gpt-6.1-sol, reasoning effort high) | Scribe 7 Nov; GPT 9 to 10 Nov | spoken | 84.2% (83.0 to 85.4) | 2.3 s | $1.71 | β | cloud, direct |
| Gemini 4 Argon (google/gemini-4-argon) | 8 Nov | spoken | 85.2% (84.1 to 86.5) | 3.8 s | $1.97 | β | cloud, OpenRouter |
| Gemini 4 Carbon (google/gemini-4-carbon) | 12 to 13 Nov | spoken | 85.1% (83.8 to 86.3) | 7.8 s | $3.47 | β | cloud, Vercel AI Gateway |
| Gemini 3.8 Flash (google/gemini-3.8-flash) | 8 Nov | spoken | 84.8% (83.6 to 86.0) | 3.3 s | $1.61 | β | cloud, OpenRouter |
| Clef-omni (Cloudflare Clef-omni) | 7 Nov | spoken | 82.4% (81.2 to 83.7) | 385 ms | $0.29 | β | cloud, OpenRouter |
| GPT Realtime (gpt-realtime-2.1) | 8 Nov | spoken | 70.8% (69.4 to 72.3) | 1.1 s | $5.04 | β | cloud, direct |
| Qwen3.8 Omni Flash (qwen/qwen3.8-omni-flash) | 8 Nov | spoken | 70.8% (69.3 to 72.2) | 4.8 s | $0.37 | β | cloud, OpenRouter |
| MiMo v2.6 Pro (xiaomi/mimo-v2.6-pro) | 8 Nov | spoken | 68.8% (67.3 to 70.4) | 3.5 s | $0.12 | β | cloud, OpenRouter |
| ElevenLabs Scribe v2 then Jev (Scribe v2; TypeSafe Jev) | 7 Nov | spoken | 66.8% (65.4 to 68.3) | 868 ms | $0.39 | β | cloud, direct |
| ElevenLabs Scribe v2 then OpenAI Decisions (Scribe v2; OpenAI Decisions API) | 8 Nov | spoken | 58.3% (56.8 to 59.8) | 947 ms | $0.41 | β | cloud, direct |
| Gemini Decision 1 (google/gemini-decision-1) | 12 to 13 Nov | spoken | 52.6% (51.0 to 54.1) | 872 ms | $0.10 | β | cloud, OpenRouter |
Hunch's intervals are Wilson score intervals; the cloud systems' are their runs' bootstrap over test items, stratified by intent. No answer counts as wrong, for example GPT Realtime's 27 empty replies and OpenAI Decisions' 141 refusals. A route through ElevenLabs Scribe v2 adds Scribe's median time and cost to the model's.
- A different measure from the rest of this page. This counts the command's label right, so its figures do not compare with the both-answers figures. Hunch's figure is version 1.0 scored as it learned from SLURP's training sentences alone, with every command given a label. As shipped, 1.0 also leaves out 12 of SLURP's 11,514 training sentences and adds 117 written examples; on this test set those differences touch at most 10 typed and 9 spoken answers, 0.34 and 0.33 points.
- Cloud models and routes change. Each row gives the date measured and the folded table the version. The Where it runs column says how each was called; in our check the Vercel AI Gateway added 0.1 to 1.4 s a request. Cloud times are one request at a time from one Mac over the network.
- How Hunch is timed. Times measured on a MacBook M1 Pro: medians over other items (200 typed commands, 100 recordings), with one setting for every Hunch time in a chart.
- Batched runs are not charted. Sent in batches of 20 through its subscription, Claude Opus 5.5 scored 90.0% typed and ElevenLabs Scribe v2 then Claude Opus 5.5 88.2% spoken; those runs give no time per command.
- Siri and Alexa: not measured. Scoring them needs the devices and a person speaking to them, and this page quotes no one else's figures.
Against the open home systems, on a different measure. Home Assistant's own sentence matcher, the language models Qwen3-0.6B and Qwen3-1.7B, and acon96's Home-Llama-3.2-3B were given the 321 typed commands that control a device. This counts both answers right (what to do and what kind of thing), not the label above, so it sits apart from the cloud charts; the tables and cautions are under Against open systems.

Teach it a command

Show Hunch three ways of saying something new and it understands the command straight away, on your device, with no retraining.

In our tests we took commands away from Hunch, such as making a coffee, starting the hoover, switching off a smart plug, setting an alarm and playing a podcast, and taught each back from a few examples. More examples help:
| Examples given | 1 | 3 | 5 | 10 |
|---|---|---|---|---|
| Typed, then recognised when typed | 69.8% | 81.1% | 83.3% | 86.3% |
| Spoken, then recognised when spoken | 42.8% | 64.7% | 72.0% | 80.8% |
Recognised means a new way of saying the command came back as the command taught. Measured with version 1.0, which teaches the same way, on 10 of SLURP's commands, chosen by hand; on 14 other commands, three typed examples gave 72.6%. Give it 3 examples; a spoken example helps spoken commands only. Your examples stay on your device, apart from the ones Hunch ships with, and you can list and remove them.
Against open systems
Measured with version 1.0 and carried here as published on 1.0's page. 1.1 runs the same encoder and voice files; its own figures are under What's new in 1.1.
We gave the open systems people use to run a home SLURP's test commands. Typed: Home Assistant's own sentence matcher, the language models Qwen3-0.6B and Qwen3-1.7B with Home Assistant's tools for the house, and acon96's Home-Llama-3.2-3B with its own. Spoken: each of them behind Parakeet, Home Assistant's default speech-to-text for English, and Speech-to-Phrase, Home Assistant's local voice add-on. The tables count the 321 typed and 295 spoken commands that control a device, the ones every system has a tool for. Both answers right means what to do and what kind of thing, both right.
| System | File size on disk | Both answers right | Time per command | Where it runs |
|---|---|---|---|---|
| Hunch-1 Home | 243 MB | 86.6% | 37 ms | your device |
| acon96/Home-Llama-3.2-3B | 1.9 GB | 67.6%* | 658 ms | your device |
| Qwen3-1.7B | 1.1 GB | 59.8% | 875 ms | your device |
| Home Assistant's matcher | 8.5 MB | 27.1% | 1.8 ms | your device |
| Qwen3-0.6B | 397 MB | 6.2% | 361 ms | your device |
Home Assistant's matcher is faster, at 1.8 ms, but gets 27.1% right: it answers only the phrasings written for it. With the matcher first and Home-Llama-3.2-3B for the rest, 70.1%. Against the three language models Hunch is 10 to 24 times faster. * 72% if Home-Llama-3.2-3B's shopping-list answers are read generously.
| System | File size on disk | Both answers right | Time per command | Where it runs |
|---|---|---|---|---|
| Hunch-1 Home | 314 MB | 78.3% | 97 ms | your device |
| Parakeet then acon96/Home-Llama-3.2-3B | 2.6 GB | 66.8%* | 766 ms | your device |
| Parakeet then Qwen3-1.7B | 1.8 GB | 48.1% | 935 ms | your device |
| Parakeet then Home Assistant's matcher | 670 MB | 23.7% | 98 ms | your device |
| Parakeet then Qwen3-0.6B | 1.1 GB | 10.2% | 460 ms | your device |
| Speech-to-Phrase | 467 MB | 6.4% | 114 ms | your device |
Hunch answers from the sound itself; each open system hears the recording through Parakeet, Home Assistant's default speech-to-text, and behind every speech-to-text engine tried, the cloud's best (ElevenLabs Scribe v2) included, every open system is less accurate. Against the language-model routes Hunch is 5 to 10 times faster; Parakeet then the matcher is about as fast (98 ms against 97 ms). Speech-to-Phrase turns away 96.9% of 958 recordings: it accepts only its own fixed command phrases. * 71% if Home-Llama-3.2-3B's shopping-list answers are read generously.
Times are medians on one MacBook M1 Pro, each system at its fastest setting; sizes are each system's smallest published files, on disk. The shipped full-size ONNX build of Hunch answers a typed command in 21 ms on the same Mac, the small 4-bit build in 25 ms. Qwen3 had Home Assistant's own tools for the house, Home-Llama-3.2-3B its own services.
Against Home-FunctionGemma-270m
acon96/Home-FunctionGemma-270m is a published open-weight model that runs a home by writing tool calls. Both models were given SLURP's typed test commands; the table counts the 321 that control a device, the only ones the other model has a tool for (measured 16 Nov 2026). Both answers right means what to do and what kind of thing, both right.

| System | Size | Both answers right | Time per command | Where it runs |
|---|---|---|---|---|
| Hunch-1 Home, small build (ONNX Runtime, 4-bit) | 207 MB | 86.3% | 25 ms | your device |
| Hunch-1 Home, full size (ONNX Runtime) | 1,117 MB | 86.6% | 21 ms | your device |
| Home-FunctionGemma-270m, 4-bit file | 242 MB | 43.3% | 165 ms | your device |
| Home-FunctionGemma-270m, 8-bit file | 292 MB | 44.9% | 183 ms | your device |
| Home-FunctionGemma-270m, full precision (bf16, its best here) | 543 MB | 45.8% | not timed | your device |
On all 735 and 1,028 of SLURP's home commands, which add 414 and then a further 293 that the other model has no tool for, Hunch gets 89.7% and 88.5%, the other model 35.2% and 34.0% (full precision).
- Caution: a check of our setup. Given 206 of its own publisher's test requests in our setup, the other model wrote the expected tool and device on only 80 to 89 of them, by file. In a second runtime, Transformers with the publisher's full-precision weights, the first 10 of those misses were wrong too (10 of 10); this is a check of the setup, not an accuracy.
- The times cover different work. In its time the other model also writes a short reply and names the device, with its device list already cached, its best case. Medians on a MacBook M1 Pro, four threads, one command at a time. Size counts the model files, the tokenizer included.
- Memory. Each timing process's peak: Hunch 1,075 MB at full size and 680 MB for the small build; the other model 965 MB (8-bit) and 869 MB (4-bit). The small build uses less memory than the other model's 4-bit file.
Limits
- This version was tested in English only.
- It names the action and the kind of thing, one command at a time; it does not find the device or the room, and it does not carry out the command. Your app does that.
- It acts on more look-alike sentences than 1.0. Sentences about home devices that are not commands, such as "I used to lock the door": of people's own, 1.1 declines 200 of 228 (87.7%), against 217 (95.2%) for 1.0.
- A far microphone is its weak spot. In an earlier test, Hunch's voice fell from 80.5% labelled right on headset recordings to 64.7% on far-microphone recordings of the same 2,648 commands, while Gemini 4 Argon held 84.4%. 1.1's voice is measured on read speech from a headset.
- Its voice is unmeasured on the new commands, since no recording of them exists yet. Only 8 commands have 30 or more real test sentences; the rest have fewer (some have none) and are unmeasured one by one.
- Its list of actions is longer than 1.0's, and an older copy of the code refuses this version's examples: use the
hunch_homeshipped with it.
Technical details
How it was measured, every figure, how it works
How it was measured (run NR, 16 Nov 2026). The cut-offs were chosen on development sentences, then each test set was scored. Real home commands come from people's posts and videos ("people's own words"), Home Assistant's test sentences and vendors' pages, mostly American and mostly about one assistant; sentences a program generated from Home Assistant's templates are left out. The real test set has been read 6 times, so its figures are not an untouched confirmation. "Not for me" to everything scores 0.0% on the home commands and 100.0% on the look-alikes. The gain on people's own commands is +32.9 points (95% interval +28.5 to +37.3, resampling the 257 posts and videos the sentences came from). Of 100 commands and 100 look-alike sentences, each version at the cut-off it ships with:
| Of 100 | Cut-off | Done right | Done wrong | Refused | Look-alike sentences acted on |
|---|---|---|---|---|---|
| Hunch-1.1 Home | 0.86 | 70.9 | 12.2 | 16.9 | 12.3 |
| Hunch-1 Home (1.0) | 0.88 | 38.0 | 16.0 | 46.0 | 4.8 |
The rise in look-alikes acted on comes with the changed lookup and the lower typed cut-off (0.86 against 0.88): at the same cut-off of 0.86, 1.1 acts on 12.3% of them and 1.0 on 9.6%.
| Measure, both answers right | Hunch-1.1 Home | Hunch-1 Home (1.0) |
|---|---|---|
| People's own home commands | 70.9% (n = 474) | 38.0% |
| All real home commands | 75.7% (n = 798) | 37.7% |
| The 24 new commands, all real sentences | 75.6% (n = 213) | 0.0% |
| Commands 1.0 already answered, all real sentences | 77.6% (n = 571) | 52.7% |
| People's own commands with no stored sentence within one word | 66.2% (n = 263) | 31.2% |
| SLURP typed, every test command (SLURP's labels) | 95.3% (n = 2,974) | 95.5% |
| SLURP typed, commands it covers | 88.6% (n = 1,028) | 88.5% |
| SLURP headset voice, every test recording (SLURP's labels) | 89.4% (n = 2,766) | 90.9% |
| SLURP headset voice, commands it covers | 76.8% (n = 958) | 80.5% |
| SLURP headset voice, speakers the voice adapter never heard | 89.5% (n = 475) | 90.1% |
On SLURP's recordings 1.1 is -1.5 points against 1.0 (95% interval -2.1 to -1.0, resampling 110 speakers). By kind of thing, people's own words, 1.1 against 1.0 (a kind with fewer than 30 test sentences is unmeasured): Lights 89.5% against 77.6% (n = 76); Climate 85.7% against 56.1% (n = 98); Security 57.7% against 7.7% (n = 52); Speakers & TVs 64.9% against 26.6% (n = 94); Other device 53.1% against 21.0% (n = 81); Timers and alarms unmeasured (n = 24); Scenes unmeasured (n = 28); Water unmeasured (n = 13); Weather unmeasured (n = 6); Lists unmeasured (n = 2). A request that names only a room ("switch the loft off") is labelled Other device in the test set, though most people mean the lights there; Hunch gets 6 of the 19 such test sentences right by that label.
What changed, in full. 1.1 stores 1,074 real sentences as examples, as text, with their two answers: mostly home commands, and some that only sound like one, stored with "not for me"; most were typed in people's public posts or said in public videos about home assistants, the rest are Home Assistant's own test sentences and example commands from vendors' help pages. It adds 880 example sentences written by a language model for this release. With them it answers 24 commands that 1.0 could not answer at all (asking about lights, heating, security, water and other devices; dimming lights to a level; setting blinds to a level; setting the temperature of water and of other devices; opening and closing doors and water valves; switching security and water on and off; next, previous and announce on speakers; more time, less time and stopping on timers and alarms; turning a scene off). The typed cut-off of 0.86 was chosen on development sentences by a rule fixed beforehand (the highest that keeps 95.0% of the development answers that were right with no cut-off; it keeps 96.1%); the cut-off for speech stays 0.37. Every post, video or page was put on one side only: none of the stored sentences, and none from a source they came from, is in the development or test sentences.
How it works. Hunch-1.1 Home uses the same encoder as 1.0, unchanged: the encoder turns a sentence into a vector, a list of numbers that places sentences of similar meaning close together. The lookup stores example sentences as vectors with their labels: 11,502 of SLURP's training sentences (12 of SLURP's 11,514 are left out, as in 1.0), 117 written examples from 1.0, 880 from 1.1 and 1,074 real sentences, 13,573 in all. A new sentence takes the label of its closest stored example, and a fixed table turns the label into the two answers. For voice, the encoder hears the recording through its audio part, with a small adapter fine-tuned on SLURP's headset recordings (unchanged from 1.0), so a recording is answered from the same lookup. The answer is "not for me" when the closest example is one it declines, or the closest shipped example is not close enough: 0.86 for typed text and 0.37 for speech against a typed example (0.40 and 0.50 against spoken examples, which as shipped apply to none), in lookup/settings.json. Your own examples are held to no cut-off, so a command you teach is answered whenever one of your examples is the closest match. The encoder ships in encoder/.
Where the figures come from. 1.1 against 1.0, people's own words and SLURP: run NR. Teaching: run TE, on 1.0. The far microphone: run L3. Builds: the builds check for 1.1. The comparisons with other systems are version 1.0's (below).
Version 1.0: how it was measured, teaching, the comparison
How it was measured. On SLURP's test set (runs HM and TE, 15 Nov 2026), with every setting chosen on SLURP's development set. Two choices were made after the first test results had been seen, which of SLURP's sentences Hunch learns from and how it answers commands you teach; the figures before and after each are given below. "Not for me" to everything would score 65.4% typed and 65.4% spoken. Commands it covers, wrongly declined: 10.4% typed, 11.7% spoken. Recordings of speakers Hunch never heard in training: 90.1% of every test command right (n = 475). Hunch leaves out 12 of SLURP's 11,514 training sentences, ones whose label SLURP's other sentences contradict; this was decided after the first test results had been seen, and with every sentence kept the figures were 95.4% typed and 90.9% spoken. The first example under "What it does", "turn on the kitchen lights", is the sentence that prompted it. Across three trainings of Hunch's voice from different random starts, spoken accuracy ranged from 90.7% to 90.9%. Without the written examples for heating, locks, blinds and scenes, typed text scores 95.6%.
Where the figures come from. Accuracy, both answers and the label measure: run HM (the label measure under How it compares is its amendment 2). Typed times and the comparison with Home-FunctionGemma-270m: run HS. The open home systems: runs OH (typed) and OV (spoken). Spoken times: run VB. The gateway check: run NM. The batched runs: L1 (typed) and L2X (spoken). Teaching: run TE. The far microphone: run L3. People's own words: run NR.
Teaching. Taught from 3 typed examples, a command was recognised when spoken 57.1% of the time (55.2% to 59.4% across draws; n = 439 recordings; the typed figures rest on 471 sentences). A spoken example helps spoken commands only, so a command you will also type needs typed examples. Five typed and five spoken examples together did better for a spoken command than five of either kind (development set). How Hunch answers a command you teach was changed after the first test results had been seen (run TE, amendment 2). As first planned, a command taught from three typed examples was recognised when typed 65.5% of the time, against 81.1% as shipped (five: 71.4% against 83.3%). The change has a measured cost on SLURP's test set: a command taught with 5 or 10 spoken examples wrongly takes 0.50% and 0.83% of other spoken commands (0.51% and 0.96% when the examples come from speakers Hunch never heard in training, measured on the 9 and 6 of the 10 commands that have enough such recordings); typed examples take about 0.05% of other typed commands and 0.09% of other spoken commands, even at ten examples. The built-in commands, heating, locks, blinds and scenes included, are answered as before. The cost adds up when you teach several commands. These figures are for SLURP's own commands; a command unlike anything in SLURP may need more examples, and for spoken commands they are an upper estimate, since Hunch heard these commands' recordings in training.
The comparison. The other model ran in its publisher's format: its own published files, its prompt with a house of eight devices, greedy decoding. Its bare dim, brighten, recolour, louder, quieter and mute calls, which do not say which way, count as right, in its favour; counted wrong, it scores 28.0% (full precision), 27.1% (8-bit) and 26.2% (4-bit). Each Hunch time and memory is the worse of two passes over 200 commands, each of the other model's the better; the small build is 6.6 times as fast as the 4-bit file. Memory differs from the figures in the build repositories' read-mes, which measure the builds alone. Only typed English commands were compared.
Builds for devices
Smaller builds ship in their own repositories, each with everything it needs to answer. The main repository holds the full-size model. The ONNX repository also holds the full-size typed model at full precision, the route behind the typed times (typed-full/; see Run it).
| Format | What runs it | Typed size | Voice size | Repository |
|---|---|---|---|---|
| ONNX | ONNX Runtime on processors | 206.7 MB; 1,116.8 MB | 277.5 MB | xevall/hunch-1-home-ONNX |
| CoreML | Core ML on iPhone and Mac | 275.8 MB | 278.4 MB; 434.4 MB | xevall/hunch-1-home-CoreML |
| LiteRT | LiteRT and MediaPipe on phones | 164.6 MB | not available | xevall/hunch-1-home-LiteRT |
| GGUF | llama.cpp and ggml runtimes | 175.7 MB | not available | xevall/hunch-1-home-GGUF |
Sizes count model files, a typed build's tokenizer included; each download also holds the runtime and Hunch's examples. No build has yet been tested on a phone, a watch or a Raspberry Pi.
The demo pages. The 3D houses at xevall.com/hunch-home run Hunch-1.1 Home's typed ONNX build in your browser tab; nothing you type leaves your device. The demo page on Hugging Face (huggingface.co/spaces/yungbose/hunch-1-home) takes typed and spoken commands and teaching by typing or speaking. A taught command is kept for your visit only. That page keeps what you type and say, with the answers it gave, to test and improve Hunch; switch off "Help improve Hunch" beside the microphone and nothing is kept. To have yours removed, write to privacy@xevall.com. The screenshots here are of that page on a laptop with this version, version picker hidden; the spoken one plays a SLURP test recording into it.
Licence and credits
Open weights, free for non-commercial use. The model, its weights and data files, is licensed under CC BY-NC 4.0 (LICENSE). The runtime code (hunch_home/, example.py and check_ten.py) is under the Apache License 2.0 (hunch_home/LICENSE). Commercial use of the model needs xevall's permission: answer Yes to the commercial question on the access form, or write to licensing@xevall.com, and we will reply. Third-party credits and use policies are listed in NOTICE.
SLURP (Bastianelli, Vanzo, Swietojanski and Rieser, EMNLP 2020; github.com/pswietojanski/slurp) supplied the training sentences in the lookup, the recordings the voice adapter was trained on, and its test sets. SLURP's text is under CC BY 4.0, and its sentences in lookup/sentences.json stay under that licence; 112 of them were given answers that differ from SLURP's labels. SLURP's audio is under CC BY-NC 4.0, a non-commercial licence, and the voice adapter was trained on those recordings; no recording is included here. The real sentences come from people's public posts and videos about home assistants, from Home Assistant's intent test sentences (github.com/OHF-Voice/intents, by its contributors, CC BY 4.0) and from vendors' help and developer pages; NOTICE says what was changed and on what terms each kind ships. 1.0's written examples were written by Claude Fable 5.2 and 1.1's by Claude Opus 5.5, for this release. This is Hunch-1.1 Home, version 1.1 (tag v1.1), made by xevall.
- Downloads last month
- 50