How doesKutup Baud work?

Kutup Baud in four facts

• New architecture28 → 30 blocks

  2 structure blocks, 8 control tokens, a decision head and 5 shape grammars, all in one GGUF file.

• Full fine-tune627.5 M

  weights, every one trained: not LoRA adapters, the model itself.

• In your browser395 MB

  downloads once; runs 100% in the browser with WebAssembly and WebGPU.

• Closed-book exam37.3%

  the file your browser runs (Q4_K_M), on 713 questions. The 27-billion-parameter teacher, closed book: 38.1%; untouched Qwen3-0.6B: 10.4%.

The idea in one machine

Think of Baud as a bench engraver: it first decides which stencil the answer needs, then the stylus can only cut through that stencil’s open windows.

How a question gets its answer

Only the model files come from the server, once. The question and the answer stay in your browser.

The plan: four questions, one pass

Before Baud writes anything, it answers four typed questions about your message. This is not a separate model: it is the same file’s decision head, run through llama.cpp’s decision-model interface (System One).

These are the probabilities the installed model gave in the browser.

Six shapes, two gates

The decision head picks the shape; a grammar (GBNF) enforces it while the answer is written. The grammars are stored inside the model file.

Qwen3-0.6B and Kutup Baud, side by side

What is inside the file

The structure blocks start as copies of the last block with their output projections set to zero, so at first they change nothing and learn only what the base model lacked.

A full fine-tune and a new architecture, together

Why both? The new blocks and tokens carry the structure engine; the full fine-tune lets the rest of the model learn to work with that engine and to hold the protocol knowledge. Training only adapters (LoRA) would have left the base model as it was.

How Baud learned

Every weight of Qwen3-0.6B was retrained (a full fine-tune, not LoRA). The teacher is an open 27-billion-parameter model; the student is Baud, small enough for a browser at 0.6 billion.

1. A Documents2,195 passages from 34 documents on 4 protocols
2. B TeacherQwen3.8-27B wrote 32,773 question–answer pairs; 27,988 passed a strict check
3. C Made by code2,297 examples: frames, codes, tables; every value exact
4. D Training set37,746 chats + 79,887 decision examples; 3% held out
5. E TrainingFirst the new parts alone (300 steps), then every weight
6. F ExamA closed-book exam of 713 questions
7. G ExportGGUF, Q4_K_M; split into parts

Where the knowledge comes from

The documents were read only by the teacher model, which wrote question–answer pairs from them in its own words. No document text was used as training text, published or shipped with Baud.

How good is it?

The exam questions were written from the documents and kept out of training. Baud, the base model and the 27-billion-parameter teacher answered the same questions without seeing any document; the teacher graded the answers without knowing who wrote them. The “Q4_K_M, the file in your browser” row is the quantized file your browser downloads, answering through the app’s own path in llama.cpp (the decision head plans, the grammar holds the shape).

The decision head

Accuracy of the four decision questions on held-out messages:

• Protocol99.3%
• Shape82.0%
• In scope100%
• English100%

• 82.1%of held-out chats with the right shape, language and scope
• 118 / 120grammar-constrained answers fit their shape exactly (Q4_K_M, llama-server)
• 700most answer tokens
• 0temperature: the same question gives the same answer

Size and quality

Quantisation stores the weights in fewer bits: the file shrinks and perplexity moves a little. Three candidate files took the exam through the app’s path; their differences are within the noise of 713 questions (about ±1.8 points). The browser downloads the highlighted file, the balance of download size and accuracy.

• bf16perplexity 4.661,202 MiB
• Q8_0perplexity 4.64641 MiB
• Q5_K_Mperplexity 4.44 · exam 38.1%444 MiB
• Q4_K_Mperplexity 4.82 · exam 37.3%395 MiB
• IQ4_XSperplexity 4.62 · exam 36.2%366 MiB

Using it elsewhere

The same file runs with llama.cpp. On Hugging Face: yunusemrejr/Baud-0.6B ↗

llama-server -m baud-0.6b-q4_k_m-00001-of-00005.gguf -c 2048
curl localhost:8080/v1/systemone -d '{"state": "Decode 11 03 00 6B 00 03 76 87",
  "questions": {"shape": {"type": "choice", "instructions": "Which answer shape fits the message best?",
  "criteria": {"prose": null, "table": null, "steps": null, "list": null, "frame": null, "code": null}}}}'

Limits

• 0.6 billion parameters: Baud can be wrong, and the smaller the detail, the more likely.
• Register maps, vendor defaults and product behaviour are not in the standards, and not in Baud. Take them from the device documentation.
• The app’s checker verifies only what it can recompute (CRC, LRC, MBAP length, frame header, hex values, topic matching); it does not verify Baud’s explanations.
• Baud is weakest at number conversion and building frames: it can slip when it turns hex into decimal or writes request bytes. The app marks such slips in frame tables; compare bytes it builds with your device documentation.
• Writing code is not Baud’s strength; check short commands and samples before you use them.
• The exam measures questions written from the documents; it is not an independent field-accuracy measurement.
• Verify critical settings with vendor documentation, the site procedure and a qualified engineer.