Instructions to use mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b")
model = AutoModelForCausalLM.from_pretrained("mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b

SGLang

How to use mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b with Docker Model Runner:
```
docker model run hf.co/mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b
```

Heed weight-average ("soup"), Qwen3.5-0.8B (EXP-031): two models averaged

Research checkpoint, not the app model. The model inside Heed is heed-tasks-qwen3-0.6b. This one uses the old, wide output format (intent and voice commands as well as items) on the Qwen3.5-0.8B base. It was scored on the older guide-v2 yardstick, not by the blind judge, and it was never put on a phone.

What it is

This is the only weight-averaged model in the Heed study. It is the element-wise average, computed in fp32, of two independently trained models from the same base:

heed-simnotes-e2-qwen3.5-0.8b (EXP-031 run E2, epoch 3: D3 data plus 1,109 simulated notes plus extra copies of 306 mistake notes), and
the EXP-031 D3 seed-1 run, epoch 3 (the D3 data only, a different seed; not published separately).

No training was run for the soup. Building and scoring it took about 6 minutes.

Why this model exists

EXP-031 found that simulated notes brought no measurable gain and that two seeds of the same recipe differ by about 3 points (47.2% and 44.2% fully right). The soup (run e9) is the one arm that averages weights instead of training: it combines a model that saw the simulated notes with one that did not, at no training cost.

Result: it tied on "fully right" and had the fewest errors per note of any EXP-031 model, but it did worse on the 59 real notes.

Prompt and answer format (exact, old wide format)

Raw text, no chat template. The prompt lists the buckets, then the note, and ends with JSON:.

Categories:
- tasks (General): general things to do
- buy (Buy): things to purchase
- watch (Watch): movies, shows, videos to see
- ideas (Ideas): thoughts to remember
- work (Work): office and job tasks
- journal (Journal): feelings, emotions, stories with no action
Note: <the note text>
JSON:

The answer is JSON followed by EOS. An invented example:

{"i":<intent>,"items":[{"t":"Call the bank","c":"tasks","r":1,"w":"at 5"}],"cmd":[...]}

Key	Meaning
`i`	An intent label for the whole note: `capture`, `mixed`, `empty`, `journal_only`, `command` or `question`
`items`	The tasks: `t` text, `c` bucket id, `r` reminder 0 or 1, `w` spoken time words (only when there is a reminder), optional `s`:1 for "suggested"
`cmd`	Voice commands: `a` = `complete`, `query`, `delete`, `move`, `reschedule` or `rename`, with `x` the target and `to` the destination

There is no "Recorded:" date line. The default bucket list above is the exact training text (from the data builder); the prompt ends with a newline after JSON:. Intent and commands are parked in the app, and this wide format is not the app's format today.

transformers

Qwen3.5 needs a transformers release with Qwen3.5 support (5.20.2 was used).

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "mohitkrconnect/heed-simnotes-soup-qwen3.5-0.8b"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype=torch.bfloat16)

CATEGORIES = """Categories:
- tasks (General): general things to do
- buy (Buy): things to purchase
- watch (Watch): movies, shows, videos to see
- ideas (Ideas): thoughts to remember
- work (Work): office and job tasks
- journal (Journal): feelings, emotions, stories with no action
"""   # exact training text
note = "call the bank at five and buy milk on the way home"
prompt = f"{CATEGORIES}Note: {note}\nJSON:\n"   # raw prompt, no chat template

ids = tok(prompt, return_tensors="pt").input_ids
out = model.generate(ids, max_new_tokens=512, do_sample=False)  # greedy, as evaluated
print(tok.decode(out[0, ids.shape[1]:], skip_special_tokens=True))

Weights are bf16. The duplicated tied lm_head was removed before upload (752,393,024 parameters). The architecture is Qwen3_5ForCausalLM (24 layers, hybrid Gated DeltaNet attention, vocabulary 248,320).

How it was made

Setting	Value
Recipe	fp32 average of the weights of E2 epoch 3 and D3 seed 1 epoch 3. No training run, no learning rate
Parents	Both full fine-tunes of `Qwen/Qwen3.5-0.8B-Base`, lr 1e-5, 3 epochs, batch 4 × 4 = 16, max length 1,024, bf16 autocast
Parent E2	4,803 rows, 903 steps, 22.52 minutes
Parent D3 seed 1	3,388 rows, 636 steps, 17.33 minutes
Hardware / cost	The parents ran on 1 × RTX 4090; about $0.34 and $0.26 of GPU at the quoted $0.90 per hour (derived estimates, not invoices). The averaging itself used no GPU training

The chart shows the two parent runs. The soup itself has no training curve.

Parent data in short. D3 is HeedSet (400 Claude Opus-written notes plus 1,265 labelled by Claude Sonnet 5.5), 777 notes I planned (generated with ChatGPT) relabelled by Sonnet 5.5, 480 Claude brain dumps, 36 curated template notes, 140 real notes from me and five friends counted 3 times, and 10 notes typed by me. E2 adds 1,109 simulated notes in my style (written by Claude Sonnet 5.5, Gemini 3.1 Pro and GPT-5.4) and an extra copy of 306 mistake notes. Labels come from Sonnet 5.5, with no per-note human check. English only.

Results

Read this first. The scores are "fully right" shares against the older guide-v2 key, on a 199-note yardstick (59 real notes + 140 HeedSet notes), scored by a judgement-free scorer. A note is fully right at L3 when nothing is missing, extra, in the wrong bucket, or wrong in reminder or time. They are not comparable with the word-overlap F1 of later models or with the blind-judge numbers on the app model card. Intervals are cluster-bootstrap 95%.

Model	Fully right L3 [95% CI]	Fully right L2	Errors per note L2 / L3
Soup (this model)	47.2 [40.7, 54.3]	56.3	0.70 / 0.89
E2 epoch 3	47.2 [40.2, 54.3]	56.3	0.76 / 0.93
D3 seed 0 (EXP-030 reference, not published)	47.2	not recorded	0.76 / 0.93
D3 seed 1 epoch 3	44.2 [37.7, 51.3]	50.7	0.83 / 1.03
E1 epoch 3	42.7 [35.7, 49.8]	50.7	0.88 / 1.13

Slices of the soup: HeedSet 52.1 [44.3, 60.0] on 140 notes; real notes 35.6 [23.7, 49.1] on 59 notes, against 39.0 for the D3 seed-0 reference.

Reading:

The soup has the lowest errors per note (0.70 at L2) but the same "fully right" share as E2 and the reference.
The differences are inside the 3-point seed noise. The real-note score is lower, on only 59 notes with an interval 25 points wide.
So weight averaging gave no clear gain here. It was not tried on any other model of the study.

What it fed, and why it was not shipped

It is part of the EXP-031 negative result (D098 to D101): simulated notes plus mistake weighting brought no measurable gain. It was not shipped because it is the wide format on Qwen3.5-0.8B, whose hybrid attention could not be run through Google's official LiteRT-LM converter (D103), and because the project narrowed to tasks only on Qwen3-0.6B (D102, D103).

Limitations

A negative-result exhibit, not a product model.
199 notes (59 real), wide intervals, seed noise about 3 points.
Averaging was done once, on one pair of parents. Other pairs or weights: not run.
The model writes intent and command fields the app does not use.
Phone conversion, speed, memory, a judged score and a sealed-test score: not measured.
Memorisation of the real notes in both parents was not tested. English only.

Links

App and website: https://heed-xi.vercel.app
Source code: https://github.com/t3chw/Heed_app
App model: https://huggingface.co/mohitkrconnect/heed-tasks-qwen3-0.6b
Base model: https://huggingface.co/Qwen/Qwen3.5-0.8B-Base

Data: the synthetic part of the training, validation and test notes, with all five systems' answers and the judge's verdicts on the public test notes, is in mohitkrconnect/heed-voice-notes-to-tasks. My real notes and my friends' are not published.

License

Apache-2.0, the same as the base model. The training labels and most training notes were produced with Claude, Gemini and GPT models. Check those providers' terms before using this model to build a competing general-purpose model.