datatab/hcawn-fc7

A 5.7M-parameter model that turns a sentence into a phone action. It runs on a plain CPU.

No install: open cawnai.com, type a request, see the tool call. Free demo.

One line from your terminal (works on Linux, macOS and Windows, it calls the hosted demo):

pip install hcawn-fc
hcawn-fc --api "Add a calendar event Team Sync tomorrow at 2pm"

create_calendar_event(title='Team Sync', datetime='2026-11-05T14:00:00')

Examples (copy any line into cawnai.com or the CLI):

Turn on the flashlight
Show the Eiffel Tower on the map
Save a contact named Alex Brown, phone 555-0199
Send an email to bob@example.com with subject Meeting and body See you at 3pm
Add a calendar event Team Sync for next Monday at 2pm
It's too dark in here, switch the light on

What it does

You give it a sentence. It returns a JSON tool call for one of 7 phone actions:

Action	Arguments
send_email	to, subject, body
create_calendar_event	title, datetime
create_contact	first_name, last_name, phone_number, email
show_map	query
open_wifi_settings	none
turn_on_flashlight	none
turn_off_flashlight	none

It is built for small, fixed tool sets that must run offline, fast and cheap: no GPU, no API bill, no data leaving the device.

Results

Strict exact match: tool name and every argument value must be right. Mobile Actions eval set, 961 rows, about ±2 points of noise.

• 90.4% (int8) and 90.3% (int4) on the benchmark's own wording.
• 82.8% on 905 requests rewritten by a different LLM (GPT-4o-mini), which is a harder, more natural test.
• 86.5% with the model and its grammar alone, without the other layers (our own evaluator).

The first two numbers were re-measured with the public hcawn-fc package, so you can repeat them: verify_fc7.py is in the GitHub repo. They include the layers around the model: grammar-constrained decoding (always valid JSON, only known tools), grounding of values in the query, date and time rules, keyword triggers and a confidence gate.

Run it locally

The local engine runs on your CPU with no network. It ships for Linux x86-64. On Windows and macOS the package works as a client for the hosted demo.

pip install hcawn-fc
hcawn-fc download            # fetches int8.bin from this repo, verifies SHA-256
hcawn-fc "Turn on the flashlight"

from hcawn_fc import Local

m = Local()
r = m.call("Show me Paris on the map")
print(r.status, r.calls)     # ok [Call(name='show_map', arguments={...})]

File	Size	What
int8.bin	6.0 MB	int8 weights. The accuracy numbers above are for this one. Recommended.
int4.bin	3.9 MB	int4 packed weights: smaller file, but slower on CPU and more often held back by the confidence gate. Use hcawn-fc download int4 and --model int4 if file size matters.

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

Model details

Parameters	5,742,720 (5.74M)
Architecture	hCAWN hybrid: 6 layers (4 recurrent associative-memory layers and 2 local-attention layers), hidden size 128, 4 heads, feed-forward expansion x4, local attention window of 4,096 bytes
Vocabulary	258 symbols: the 256 raw UTF-8 bytes plus start and end markers. No tokenizer
Embedding table	33,024 parameters (0.6% of the model); almost everything is in the layers
Weights	int8 (6.0 MB) and int4 (3.9 MB), custom format for the hCAWN engine
Sequence length	pretraining on 1,024-byte sequences; fine-tuning on prompts plus answers of up to 2,048 bytes
Output	a JSON list of calls, [{"name": ..., "arguments": {...}}], decoded byte by byte

Pretraining. Next-byte prediction on a mix of English web text (FinePDFs-Edu, DCLM and FineWeb-Edu). No function-calling data was used at this stage. AdamW, peak learning rate 5e-4 with warmup and cosine decay, 64 sequences of 1,024 bytes per step (65,536 bytes). The checkpoint used here is the best one by validation loss, at step 241,000 of a planned 300,000 (about 15.8 billion bytes seen). Validation loss on WikiText-103: 1.068 nats per byte (1.54 bits per byte).

Fine-tuning. Supervised, in several stages from the pretrained checkpoint, on Mobile Actions plus paraphrases of its requests, with random changes to the form of the requests (for example removing quotes). The last stage ran 6,096 steps: 2 epochs over 8,693 original and 16,000 paraphrased requests, batch size 8.

Why 300 characters. The demo and the Python package accept requests up to 300 characters. This is a safety limit, not a limit of the model. During fine-tuning every example (tool definitions, date, request and answer) fits in 2,048 bytes. The tool definitions and date take about 1.2 KB, which leaves roughly 850 bytes for the request and the answer together. In the benchmark, 4.8% of the requests are longer than 300 characters (up to 740); the model gets 43 of those 46 right.

Training data

• Mobile Actions dataset by Google, CC BY 4.0: 8,693 training requests and 961 evaluation requests. About two thirds of the requests need one call, one third need two (rarely more). Queries and tool calls were filtered and augmented with query-form variants.
• Paraphrases of the training queries generated with Gemini 2.5 Flash Lite, filtered automatically: 30,354 generated, 16,000 used in the last fine-tuning stage.
• Evaluation paraphrases: 905 requests rewritten by GPT-4o-mini, a different model from the one that wrote the training paraphrases, and never used for training.
• Pretraining text: the web-text mix named above, English only.

No private or user data was used.

Limits

• Only the 7 tools above. It will not call anything else, and it is not a general chat model.
• English queries only.
• Relative dates ("tomorrow at 2pm") are resolved by a rule using the caller's clock, not by the model.
• Weaker on unusual phrasings ("tell him that ...", "... saying X"). The confidence gate is not a guarantee: it stops most, not all, wrong calls.
• Requests outside the 7 actions are expected to return no call. This is enforced by keyword triggers, so an unusual phrasing of a valid action can also be missed.
• The package and the demo accept requests up to 300 characters (see "Why 300 characters" above). On the 915 benchmark requests up to 300 characters accuracy is 90.3% (int8).
• Numbers are for Mobile Actions-style queries. Expect lower accuracy on different phrasing or tool definitions.

Need a model for your own tools?

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

Licence

Weights: CC BY 4.0. Please credit "CAWN AI, hCAWN-FC7 (https://cawnai.com)" and keep the Mobile Actions attribution above. Code (hcawn-fc package): Apache-2.0.