datatab/hcawn-ha

A 5.7M-parameter model that turns a sentence into a Home Assistant action. It runs on a plain CPU, offline.

You say what you want. The model returns the Home Assistant action for it. A small resolver then finds the device in your home, and the action runs.

turn off the kitchen lights
set the bedroom lamp to purple
dim the living room floor lamp to 30 percent
lock the front door
set the thermostat to 23 degrees
add milk to the shopping list
pause the living room speaker and start the robot vacuum
close the garage door

It is built for one narrow job: understanding smart-home commands locally, fast and cheap. No GPU, no cloud, no account, and no text leaving your house.

What it does

The model reads one command and returns a JSON call for one of 13 Home Assistant actions. The device is given as the words the person used ("kitchen lights"), not as an entity id. Your own registry decides what those words mean.

Action	What it does
HassTurnOn, HassTurnOff, HassToggle	lights, plugs, fans, covers, speakers, humidifiers, locks and more
HassLightSet	brightness and color
HassClimateSetTemperature	thermostat target
HassHumidifierSetpoint	humidity target
HassListAddItem	add to a shopping or to-do list
HassVacuumStart, HassVacuumReturnToBase	robot vacuum
HassMediaPause, HassMediaUnpause, HassMediaNext, HassMediaPrevious	media players

The model is only the first step. The numbers below are for the model together with the checks and the resolver around it, as described in How it is meant to be used.

Results

All numbers are for the weights in this repo. Where two numbers are given they are right / wrong. "Right" means the right action and the right device and values. "Wrong" means an action that is not what the person asked for. Everything else is a question back ("which one?") or no action.

Test	int8.bin	int4.bin
Model alone, own held-out set, 500 requests (fp32: 95.2%)	95.0%	94.8%
Whole pipeline, several commands per sentence	92.6%	92.6%
Official Home Assistant intent tests (144 sentences)	92.4% / 0.7%	91.0% / 2.1%
... with the confidence check on (threshold 0.7)	91.7% / 0.0%	90.3% / 0.7%
acon96 Home-Assistant-Requests-V2 test set	89.7% / 1.8%	89.1% / 1.4%
... with the confidence check on (threshold 0.7)	87.0% / 1.3%	84.9% / 1.2%

• The confidence check trades answers for safety. With it on, the model asks more often and does the wrong thing less often. The demo and the package default to threshold 0.7.
• Two of these test sets deserve a note. The 500-request set is held out from training: Home-Assistant-Requests-V2 test rows plus LLM-phrased requests about rooms and items that never appear in training. It is still the same kind of text as the training data. The official Home Assistant tests are public, and after we saw failures on them we added matching wordings to the training data, so that number flatters the model. The acon96 test set is the most independent check, and 89.7% is the number to trust most.
• Noise is about ±1.3 points on 500 rows and larger on the 144-sentence set.
• Rooms and groups. "Turn off the kitchen lights" resolves to every light in the kitchen. On a synthetic test house with rooms we get 92 to 96%.
• Locks and garage doors always ask first. They are never executed without a yes. Stopping a door or blind ("stop the garage door") also asks, because there is no stop action and closing would be wrong.

For scale, models used for this job today are usually 0.5B to 1B parameters or more, which is roughly 90 to 170 times larger than this one. We do not compare accuracy numbers with theirs, because they are measured on different test sets.

Files

File	Size	What
int8.bin	6.0 MB	int8 weights. Recommended: best accuracy.
int4.bin	4.1 MB	packed int4 weights, with a few sensitive layers kept at int8. 32% smaller, about 0.2 points less accurate on the model-alone test, and slightly more wrong actions on the official tests.

The weights are a custom binary format for the hCAWN engine. They are not loadable with transformers or llama.cpp.

How it is meant to be used

A model this small should not be trusted blindly with your front door, so it never works alone. The intended pipeline is:

1. Split the sentence into single commands ("turn on the lights and lock the door").
2. Model reads each command and returns the action, with a confidence score for each byte it wrote.
3. Checks: a direction guard (does "turn off" agree with the chosen action?), validation of values (is that a real color? a brightness from 0 to 100?), and a confidence threshold. When any check fails, nothing is executed and the person is asked.
4. Resolver maps the words to devices in your Home Assistant registry, including whole rooms. If it is not sure which device was meant, it asks.
5. Confirmation for locks and garage doors, then the service call.

The engine, the resolver and a Home Assistant integration will be released as a standalone package. Until then this repo contains the weights only, and the numbers above come from our own pipeline, which you cannot yet run from here. We would rather say that plainly than imply a one-line install that does not exist yet.

Model details

Parameters	5,742,720 (5.74M)
Architecture	hCAWN, the same architecture as hCAWN-FC7 (see that card for details)
Vocabulary	258 symbols: the 256 raw UTF-8 bytes plus start and end markers. No tokenizer
Output	a JSON list of calls, [{"name": "HassTurnOff", "arguments": {"name": "kitchen lights"}}], decoded byte by byte under a grammar that only allows the 13 known actions
Weights	int8 (6.0 MB) and int4 (4.1 MB)

Training. Supervised fine-tuning, starting from the public hCAWN-FC7 checkpoint, which was pretrained on English web text and fine-tuned for phone actions. For this model: 2 epochs over more than 33,000 examples, learning rate 5e-5.

Training data

• Home-Assistant-Requests-V2 by acon96 (MIT license), English part. The conversations were converted to single-command examples with the Home Assistant action as the target. Labels were repaired by rules, and examples that could not be repaired were dropped.
• Paraphrases of those requests generated with Gemini, three more wordings per example with the same answer, filtered automatically.
• LLM-phrased synthetic requests. We build the task ourselves (action, device phrase, values), and an LLM only phrases it in many ways. The answer always comes from the task, never from the LLM, and a phrasing is kept only if every device phrase and value appears in it character for character and the direction (on or off, open or close) is not contradicted.
• Templated data we generated for what the original data covers poorly: short telegraphic commands ("kitchen light on"), locks, gates and garage doors, and whole-room targets ("all the lights in the living room").
• No private data and no user data.

Limits

• English only for now. A Serbian version is planned.
• Only the 13 actions above. Not supported yet: fan speed, scenes, timers and schedules, volume, setting a blind to a position, and questions about device state ("is the door locked?"). It is not a chat model.
• Some verbs still get mapped to the wrong action in rare cases (for example "stop the stereo", "go home"), and "to be on" is occasionally read as a color. The checks catch most of these, not all.
• Not a guarantee of safety. On the independent test set about 1 to 2 requests in 100 still end in a wrong action. Do not use it for anything where a wrong action is dangerous without keeping the confirmation step for locks and doors.
• Device names it has never seen (long, unusual, non-English) are copied less reliably than common ones. The resolver fixes small typos, not everything.
• The numbers are from our own tests on English requests in the style of these datasets. Expect lower accuracy on unusual phrasing.

Need a model for your own devices?

We build small CPU-only models like this one for your tools and your phrasing, and run them on-device or on your own servers. Talk to us at cawnai.com (contact form at the bottom).

License

Weights: CC BY 4.0. Please credit "CAWN AI, hCAWN-HA (https://cawnai.com)". The model was trained from hCAWN-FC7 (CC BY 4.0) and on data from Home-Assistant-Requests-V2 (MIT, acon96), whose attribution is kept above.