Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C

docs: Clef on the qwen36 engine

JustVugg9d7807776dd4
diff --git a/README.it.md b/README.it.md
index f685af2a..9f3e22ea 100644
--- a/README.it.md
+++ b/README.it.md
@@ -551,6 +551,7 @@ altre nove famiglie di modelli linguistici, e un motore genera immagini. Ognuna
| **OLMoE** (AI2) | 7B / 1B | convertito con `c/tools/convert_olmoe_merged.py`: container **int8**, ~7 GB | `make -C c olmoe` | - |
| **Qwen-Image-2.1** (Alibaba) | modello di immagini | [`Qwen/Qwen-Image-2.1`](https://huggingface.co/Qwen/Qwen-Image-2.1) (~33 GB), checkpoint diffusers ufficiale, **nessuna conversione**: il text encoder e il diffusion transformer vengono quantizzati a int8 durante il caricamento. Immagini dentro `coli chat`, `POST /v1/images/generations` su `coli serve`. Qwen Research License: solo uso non commerciale | `make -C c qwenimage` | [qwen-image.md](docs/qwen-image.md) |
| **Laya** (Convai Innovations) | modello di decisione, 421M | [`convaiinnovations/laya`](https://huggingface.co/convaiinnovations/laya) (842 MB), checkpoint ufficiale, **nessuna conversione**: un encoder ModernBERT con una testa di decisione che risponde a domande tipizzate (choice, score, noul) con probabilità calibrate invece di generare. Servito su `POST /v1/systemone` da `coli serve`. Apache-2.0 | `make -C c laya` | [laya.md](docs/laya.md) |
+| **Clef** (Cloudflare) | modello di decisione + chat, 27B | [`Cloudflare/clef`](https://huggingface.co/Cloudflare/clef) (55 GB), convertito con `c/tools/convert_qwen36.py` (52 GB, testa inclusa): Qwen3.8-27B riaddestrato con una testa congiunta che dà un punteggio a ogni opzione di ogni domanda in un solo passaggio. `POST /v1/systemone` risponde in modo nativo, la chat funziona come su Qwen3.8-27B. Apache-2.0 | `make -C c qwen36` | [clef.md](docs/clef.md) |
Qwen3.6 offre tre container pre-convertiti: **int4-gs64** (consigliato: coseno
misurato rispetto all'ancora int8 da 0,98777 a 0,99313 e KL da 0,109 a 0,080
diff --git a/README.ja.md b/README.ja.md
index 9ea5bd03..621c4d37 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -511,6 +511,7 @@ GLM-5.2 がリファレンスモデルですが、同じストリーミング手
| **OLMoE**(AI2) | 7B / 1B | `c/tools/convert_olmoe_merged.py` で変換 — **int8** コンテナ、約 7 GB | `make -C c olmoe` | — |
| **Qwen-Image-2.1**(Alibaba) | 画像モデル | [`Qwen/Qwen-Image-2.1`](https://huggingface.co/Qwen/Qwen-Image-2.1)(約 33 GB)、公式 diffusers チェックポイント、**変換不要**: テキストエンコーダと拡散トランスフォーマーはロード時に int8 に量子化。`coli chat` では画像をインライン表示し、`coli serve` では `POST /v1/images/generations` で提供。Qwen Research License: 非商用利用のみ | `make -C c qwenimage` | [qwen-image.md](docs/qwen-image.md) |
| **Laya**(Convai Innovations) | 判定モデル、421M | [`convaiinnovations/laya`](https://huggingface.co/convaiinnovations/laya)(842 MB)、公式チェックポイント、**変換不要**: ModernBERT エンコーダと判定ヘッドで、型付きの質問(choice、score、noul)に生成ではなく較正済みの確率で答える。`coli serve` の `POST /v1/systemone` で提供。Apache-2.0 | `make -C c laya` | [laya.md](docs/laya.md) |
+| **Clef**(Cloudflare) | 判定モデル + チャット、27B | [`Cloudflare/clef`](https://huggingface.co/Cloudflare/clef)(55 GB)、`c/tools/convert_qwen36.py` で変換(52 GB、ヘッド込み): Qwen3.8-27B を追加学習し、すべての質問のすべての選択肢を 1 回のパスで採点する結合スキーマヘッドを付けたモデル。`POST /v1/systemone` にネイティブに答え、チャットは Qwen3.8-27B と同様に動作。Apache-2.0 | `make -C c qwen36` | [clef.md](docs/clef.md) |
Qwen3.6 には変換済みコンテナが 3 つあります: **int4-gs64**(推奨 — int8 のアンカーに対するコサイン類似度は
行単位と比べて 0.98777 → 0.99313、KL は 0.109 → 0.080 と計測されており、量子化誤差が約 44% 少ない)、
diff --git a/README.md b/README.md
index 590de07b..2b0161c7 100644
--- a/README.md
+++ b/README.md
@@ -532,6 +532,7 @@ or from `model_index.json` for the image model):
| **OLMoE** (AI2) | 7B / 1B | converted with `c/tools/convert_olmoe_merged.py` — **int8** container, ~7 GB | `make -C c olmoe` | — |
| **Qwen-Image-2.1** (Alibaba) | image model | [`Qwen/Qwen-Image-2.1`](https://huggingface.co/Qwen/Qwen-Image-2.1) (~33 GB), official diffusers checkpoint, **no conversion**: the text encoder and the diffusion transformer are quantized to int8 while loading. Pictures inline in `coli chat`, `POST /v1/images/generations` on `coli serve`. Qwen Research License: non-commercial use only | `make -C c qwenimage` | [qwen-image.md](docs/qwen-image.md) |
| **Laya** (Convai Innovations) | decision model, 421M | [`convaiinnovations/laya`](https://huggingface.co/convaiinnovations/laya) (842 MB), official checkpoint, **no conversion**: a ModernBERT encoder with a decision head that answers typed questions (choice, score, noul) with calibrated probabilities instead of generating. Served on `POST /v1/systemone` by `coli serve`. Apache-2.0 | `make -C c laya` | [laya.md](docs/laya.md) |
+| **Clef** (Cloudflare) | decision model + chat, 27B | [`Cloudflare/clef`](https://huggingface.co/Cloudflare/clef) (55 GB), converted with `c/tools/convert_qwen36.py` (52 GB, head included): Qwen3.8-27B post-trained with a joint schema head that scores every option of every question in one pass. `POST /v1/systemone` answers natively, chat works as on Qwen3.8-27B. Apache-2.0 | `make -C c qwen36` | [clef.md](docs/clef.md) |
Qwen3.6 ships three pre-converted containers: **int4-gs64** (recommended — measured
cosine to the int8 anchor 0.98777 → 0.99313 and KL 0.109 → 0.080 against per-row, i.e.
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 53747156..318f7d70 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -464,6 +464,7 @@ GLM-5.2 是参考模型,但同样的流式方法还能运行另外九个语言
| **OLMoE**(AI2) | 7B / 1B | 用 `c/tools/convert_olmoe_merged.py` 转换,**int8** 容器,约 7 GB | `make -C c olmoe` | 无 |
| **Qwen-Image-2.1**(Alibaba) | 图像模型 | [`Qwen/Qwen-Image-2.1`](https://huggingface.co/Qwen/Qwen-Image-2.1)(约 33 GB),官方 diffusers checkpoint,**无需转换**:文本编码器与扩散 transformer 在加载时量化为 int8。`coli chat` 中直接显示图片,`coli serve` 提供 `POST /v1/images/generations`。Qwen Research License:仅限非商业用途 | `make -C c qwenimage` | [qwen-image.md](docs/qwen-image.md) |
| **Laya**(Convai Innovations) | 决策模型,421M | [`convaiinnovations/laya`](https://huggingface.co/convaiinnovations/laya)(842 MB),官方 checkpoint,**无需转换**:ModernBERT 编码器加决策头,对类型化问题(choice、score、noul)给出校准后的概率,而不是生成文本。由 `coli serve` 在 `POST /v1/systemone` 上提供。Apache-2.0 | `make -C c laya` | [laya.md](docs/laya.md) |
+| **Clef**(Cloudflare) | 决策模型 + 聊天,27B | [`Cloudflare/clef`](https://huggingface.co/Cloudflare/clef)(55 GB),用 `c/tools/convert_qwen36.py` 转换(52 GB,含决策头):在 Qwen3.8-27B 上继续训练并加上联合模式头,一次前向为每个问题的每个选项打分。`POST /v1/systemone` 原生作答,聊天与 Qwen3.8-27B 相同。Apache-2.0 | `make -C c qwen36` | [clef.md](docs/clef.md) |
Qwen3.6 提供三个预转换容器:**int4-gs64**(推荐:与 per-row 相比,对 int8 基准的余弦相似度
实测从 0.98777 提升到 0.99313,KL 从 0.109 降到 0.080,即量化误差减少约 44%)、作为 A/B 基线的
diff --git a/README.zh-TW.md b/README.zh-TW.md
index d086be64..0491a121 100644
--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@@ -465,6 +465,7 @@ GLM-5.2 是參考模型,但同樣的串流方法還能執行另外九個語言
| **OLMoE**(AI2) | 7B / 1B | 以 `c/tools/convert_olmoe_merged.py` 轉換,**int8** 容器,約 7 GB | `make -C c olmoe` | 無 |
| **Qwen-Image-2.1**(Alibaba) | 圖像模型 | [`Qwen/Qwen-Image-2.1`](https://huggingface.co/Qwen/Qwen-Image-2.1)(約 33 GB),官方 diffusers checkpoint,**無需轉換**:文字編碼器與擴散 transformer 在載入時量化為 int8。`coli chat` 中直接顯示圖片,`coli serve` 提供 `POST /v1/images/generations`。Qwen Research License:僅限非商業用途 | `make -C c qwenimage` | [qwen-image.md](docs/qwen-image.md) |
| **Laya**(Convai Innovations) | 決策模型,421M | [`convaiinnovations/laya`](https://huggingface.co/convaiinnovations/laya)(842 MB),官方 checkpoint,**無需轉換**:ModernBERT 編碼器加決策頭,對型別化問題(choice、score、noul)給出校準後的機率,而不是生成文字。由 `coli serve` 在 `POST /v1/systemone` 上提供。Apache-2.0 | `make -C c laya` | [laya.md](docs/laya.md) |
+| **Clef**(Cloudflare) | 決策模型 + 聊天,27B | [`Cloudflare/clef`](https://huggingface.co/Cloudflare/clef)(55 GB),用 `c/tools/convert_qwen36.py` 轉換(52 GB,含決策頭):在 Qwen3.8-27B 上繼續訓練並加上聯合模式頭,一次前向為每個問題的每個選項打分。`POST /v1/systemone` 原生作答,聊天與 Qwen3.8-27B 相同。Apache-2.0 | `make -C c qwen36` | [clef.md](docs/clef.md) |
Qwen3.6 提供三個預先轉換的容器:**int4-gs64**(推薦:與 per-row 相比,對 int8 基準的餘弦相似度
實測從 0.98777 提升到 0.99313,KL 從 0.109 降到 0.080,即量化誤差減少約 44%)、作為 A/B 基準的
diff --git a/docs/api.md b/docs/api.md
index 691a709f..2dc450ef 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -26,7 +26,7 @@ Implemented endpoints are `GET /v1/models`, `GET /v1/models/{model}`,
`POST /v1/systemone`, colibri's one decision API ([systemone.md](systemone.md)):
the request and reply of TypeSafe's Jev API, scored by a language model through
its logprob channel or answered natively by a decision model such as
-[Laya](laya.md). Chat and
+[Laya](laya.md) or [Clef](clef.md). Chat and
completion requests support JSON responses, SSE streaming, usage counts,
`max_tokens`/`max_completion_tokens`, `temperature`, `top_p`, and up to four
custom `stop` sequences. `max_tokens` is a ceiling, not a target: when the
diff --git a/docs/clef.md b/docs/clef.md
new file mode 100644
index 00000000..b90b1efc
--- /dev/null
+++ b/docs/clef.md
@@ -0,0 +1,146 @@
+# Clef on colibri
+
+[Clef](https://huggingface.co/Cloudflare/clef), by Cloudflare (Apache-2.0), is
+a decision model: give it a state (text or JSON) and typed questions
+(`choice`, `score`, `noul`) and it returns a probability for every option of
+every question in one forward pass. It is Qwen3.8-27B, post-trained, plus a
+small transformer, the joint schema head, that reads the backbone's last
+hidden states. Its model card calls its API compatible with Jev and System
+One.
+
+colibri runs it on the qwen36 engine, the one that already runs Qwen3.8-27B:
+`POST /v1/systemone` is answered natively by the head, with the request and
+the reply of TypeSafe's Jev API ([systemone.md](systemone.md)), and the same
+process still chats.
+
+## Download, convert, serve
+
+```sh
+hf download Cloudflare/clef --local-dir ~/Models/clef # 55 GB, bf16
+python3 c/tools/convert_qwen36.py --model ~/Models/clef --out ~/Models/clef_c
+make -C c qwen36
+./c/coli serve --model ~/Models/clef_c
+```
+
+The converter writes the backbone as for Qwen3.8-27B (an f16 container,
+52 GB) and copies `joint_head_config.json` and `joint_head.safetensors` beside
+it. `coli` recognises a qwen36 container that carries both files as Clef:
+the banner says `Clef · 27B`, the API model id is `clef`, `coli info` adds a
+`decision` line, `coli doctor` checks the head against the backbone, and
+`/v1/models` lists `capabilities: ["chat", "systemone"]`.
+
+Clef's backbone is not the stock one: compared tensor by tensor with
+Qwen/Qwen3.8-27B, layers 0 to 39, the embeddings, the LM head and the vision
+tower are identical, and the 186 projection and MLP matrices of layers 40 to
+63 differ. A Qwen3.8-27B container cannot stand in for it.
+
+```sh
+curl -s localhost:8000/v1/systemone -H 'Content-Type: application/json' -d '{
+ "model": "clef",
+ "state": "Our checkout started returning errors and orders are blocked.",
+ "questions": {
+ "department": {"type": "choice", "instructions": "Which team should handle the message?",
+ "criteria": {"billing": "Payments or invoices", "technical": "Bugs or outages"}},
+ "urgency": {"type": "score", "criteria": ["Can wait", "This week", "Today"]},
+ "outage": {"type": "noul", "instructions": "Is a service down?"}}}'
+```
+
+```json
+{"id": "req_973f...", "model": "clef", "provider": "colibri",
+ "answers": {
+ "department": {"type": "choice", "choice": "technical",
+ "probabilities": {"billing": 0.075526, "technical": 0.924474}, "confidence": 0.848948},
+ "urgency": {"type": "score", "score": 1.837707, "legend": {"0": "Can wait", "1": "This week", "2": "Today"},
+ "probabilities": {"0": 0.038915, "1": 0.084464, "2": 0.876622}, "confidence": 0.814932},
+ "outage": {"type": "noul", "noul": 0.86562}},
+ "usage": {"input_tokens": 300, "output_tokens": 0, "cost": 0}}
+```
+
+`input_tokens` is the length of the rendered record, every question in one
+sequence.
+
+## What the engine computes
+
+Each step follows the checkpoint's own `joint_schema_model.py` (revision
+2f3de3dd, SHA-256 0e304cf7...), which is the specification:
+
+| step | reference | in colibri |
+|---|---|---|
+| record | `systemone` | the gateway sends the record in its raw form (`CAPS decide_record=raw`): the caller's values, JSON with sorted keys, nothing defaulted |
+| rendering | `encode_record`, `question_options`, `render` | `clef_head.h` `clef_render`: the system prompt, `STATE:`, then per question `FIELD`, `ID`, `TYPE`, `INSTRUCTION` (the question id when there are none) and one `OPTION k:` per option as `{"description":...,"option_id":...}`; noul `true` then `false` with the default descriptions, choice labels sorted, score levels in order; every piece tokenized on its own, the state cut from its end to fit `max_length` 16384 |
+| tokenizer | `tokenizer.json`, transformers' `Qwen2Tokenizer` | qwen36's BPE with the exact Unicode classes and NFC for a Clef checkpoint; the regex is the one the checkpoint applies, where a combining mark is not part of a letter run |
+| backbone | `Qwen3_5Model` (text path) | qwen36's prefill over the whole record, keeping the final-normed hidden state of every position |
+| head | `JointSchemaHead.forward` | `clef_head_forward`: LayerNorm over the hidden states, span means for the instructions and the options, lexical option vectors from the LM head's rows (read at the container's precision, not the int8 copy), two evidence routing layers (options attending to the whole sequence), the option summary per question, four decoder layers over the fields, then `prior + sigmoid(gate) * (scale * cosine + residual)` |
+| answer | `systemone` | a softmax per question; the gateway shapes the Jev reply (`choice`, `score` as the expected level, `noul` as P(true)) |
+
+The head runs in f32 (512 MB). The backbone runs as Qwen3.8-27B does here:
+int8 by default (`COLI_DENSE_BITS=4` for int4).
+
+## Checked against the reference
+
+- **Tiny oracle** (`make -C c clef-tiny-check`, in CI): a random checkpoint
+ in the release's layout (`tools/make_clef_tiny.py`, numpy) and what Clef's
+ own code answers on it with transformers 5.10.2 in f32
+ (`clef_tiny/ref.json`, written by `tools/make_clef_ref.py`): 16 cases, 44
+ questions, every type, 1 to 40 options, null, empty and JSON descriptions,
+ noul criteria given, null and absent, JSON instructions and states,
+ conversations, added tokens and NFC-decomposed text in the state, the cut
+ at `max_length` and a schema that does not fit. Input ids and spans
+ identical, 44/44 decisions identical, max |dp| 2.1e-6 (tolerance 2e-5),
+ then the same fixture through `coli serve` and both TypeSafe SDKs.
+- **The real checkpoint** (`tools/compare_clef.py`, Ryzen 7 8700GE, 8
+ threads): 15 requests, 39 questions (the model card's examples, the Jev
+ examples of these docs, a contract, a conversation, unicode, JSON, a
+ 20-intent choice, nine questions in one record) against the release's code
+ in bf16, its own precision:
+
+| engine backbone | input ids | decisions | max \|dp\| |
+|---|---|---|---|
+| int8 (default) | 15/15 identical | 39/39 | 0.22 |
+| int4 (`COLI_DENSE_BITS=4`) | 15/15 identical | 39/39 | 0.22 |
+
+ The two largest differences, 0.22 and 0.21 in int8, are a code-review
+ verdict where the reference puts 0.955 on "request changes" and the
+ nine-question invoice record; both keep the reference's decision, and 8 of
+ the 15 requests stay under 0.01. A reference in f32 has not been run (the 27B in f32
+ does not fit the 61 GB of the box), so how much of the gap is the engine's
+ int8 and how much the reference's bf16 is not separated.
+
+## Speed
+
+Measured on the same box, 8 threads, every request from a cold state:
+
+| | per request |
+|---|---|
+| engine, int8, median over the 15 requests (150 to 779 tokens) | 20.4 s |
+| engine, int4, the same requests | 30.2 s |
+| reference, bf16, transformers 5.17 on the CPU, 28 of 64 layers read from disk | 10.8 s |
+| `coli serve`, the request above (300 tokens), at the client | 20.6 s, of which 1.4 ms gateway |
+
+The time is the backbone's prefill, about 15 tokens per second here; the
+reference's bf16 matrix kernels are faster on this CPU than qwen36's int8
+prefill, and int4 is slower still because the prefill is compute-bound. The
+engine's own time is in the `x-colibri-engine-ms` header.
+
+## Knobs
+
+| variable | default | meaning |
+|---|---|---|
+| `COLI_CLEF_MAX_LEN` | 16384 | the reference's `max_length`: the state is cut to fit it, a schema longer than it is a 422 |
+| `Q36_MAXT` | 8192 | the engine's context; a record longer than it is a 422 that names it, so raise it to 16384 for Clef's full budget |
+| `COLI_DENSE_BITS`, `COLI_DENSE_INT4` | int8 | as for Qwen3.8-27B ([qwen36.md](qwen36.md#the-dense-27b)) |
+
+## Limits
+
+- **No pictures.** Clef reads images and video, but only through its Python
+ `systemone()`, as PIL images; Jev's `/v1/systemone` request (both official
+ SDKs) has no image field, so neither does colibri's.
+- **Every request reads the whole record.** There is no snapshot of a state
+ across requests yet: a second request about the same document pays its
+ prefill again.
+- **Clef-Flash** (Qwen3.5-9B backbone, same head code) has the shape this
+ path expects but has not been run here.
+- The chat of the same process is Qwen3.8-27B's with Clef's post-trained
+ layers. It works (asked in English for the capital of France, it answered
+ "the capital of France is Paris" in Chinese, after a reasoning block in
+ Chinese); its quality has not been measured.
diff --git a/docs/docs.json b/docs/docs.json
index c3419bd4..fa9e4b09 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -23,7 +23,7 @@
},
{
"group": "Model engines",
- "pages": ["deepseek-v4", "kimi_k3", "qwen38", "qwen36", "inkling", "mimo", "qwen-image", "laya"]
+ "pages": ["deepseek-v4", "kimi_k3", "qwen38", "qwen36", "inkling", "mimo", "qwen-image", "laya", "clef"]
},
{
"group": "Configure and tune",
diff --git a/docs/serve_protocol.md b/docs/serve_protocol.md
index 2629c623..d0099eed 100644
--- a/docs/serve_protocol.md
+++ b/docs/serve_protocol.md
@@ -43,7 +43,9 @@ Two more keys say what kind of engine answers. `decide=1`: the engine takes
instead of scoring options through the logprob channel. `chat=0`: it has nothing
else, so the generating endpoints answer 400 with a pointer to `/v1/systemone`.
A decision engine (laya) says `decide=1 chat=0`; an engine that chats and also
-decides natively would say `decide=1` alone.
+decides natively says `decide=1` alone (qwen36 with Clef's head). `decide_record=raw`
+asks for the record in its raw form, the caller's own values (docs/systemone.md,
+"Decision engines").
## Requests (server → engine)
diff --git a/docs/systemone.md b/docs/systemone.md
index e393498f..92ce61e8 100644
--- a/docs/systemone.md
+++ b/docs/systemone.md
@@ -461,11 +461,14 @@ cannot tell which kind answered.
| engine | model | doc |
|---|---|---|
| `c/laya` | Laya (Convai Innovations): ModernBERT encoder + decision head | [laya.md](laya.md) |
+| `c/qwen36` | Clef (Cloudflare): Qwen3.8-27B, post-trained, + joint schema head; it also chats | [clef.md](clef.md) |
-A decision engine serves `POST /v1/systemone` only. Chat, completions and
-messages answer 400 with a pointer to `/v1/systemone`, and
+A decision-only engine (Laya) serves `POST /v1/systemone` only. Chat,
+completions and messages answer 400 with a pointer to `/v1/systemone`, and
`/v1/models` lists the model with `capabilities: ["systemone", "decision"]`
-(a language model says `["chat", "systemone"]`). The path is one round trip:
+(a language model says `["chat", "systemone"]`). A chat model with a
+decision head (Clef) keeps every endpoint and says `["chat", "systemone"]`;
+only its `/v1/systemone` takes the native path. The path is one round trip:
the gateway checks the request, sends it to the engine as one record, and
shapes the answer. Nothing is rendered into a prompt and no option is scored
on its own. On Laya the gateway's share is about 2 ms per request: 8.1 ms at
@@ -482,6 +485,7 @@ so a new engine writes only its model and one function.
protocol: `decide=1` (it takes `DECIDE`) and `chat=0` (it generates nothing).
An engine that also chats leaves `chat` out; the gateway then sends
`/v1/systemone` to `DECIDE` and the chat endpoints to `SUBMIT` as before.
+`decide_record=raw` asks for the raw form of the record, below.
**Request.** `DECIDE <id> <slot> <bytes>` followed by one JSON record:
@@ -510,6 +514,18 @@ An engine that also chats leaves `chat` out; the gateway then sends
default text the language-model path asks with.
- `slot` is the KV slot, for an engine that keeps state between requests.
+**The raw form.** A model whose reference renders the request into a prompt
+itself (Clef) needs what the caller sent, not the gateway's reading of it. An
+engine that says `decide_record=raw` gets the record with `"record": "raw"`
+and the same shape, with three differences: instructions are `null` when the
+caller sent none (no default text); a description is kept as sent, `""`
+included, and a noul side the caller did not describe has no `"text"` key at
+all (`null` when it was described as `null`); and a JSON value (the state,
+instructions, a description) is written with sorted keys and compact
+separators, `json.dumps(value, ensure_ascii=False, separators=(",", ":"),
+sort_keys=True)`, with `"json": true` on an option whose text is one.
+Laya gets the default form, byte for byte as before.
+
**Answer.** One `DECISION <id> <bytes>` frame, then `DONE`:
```json
@@ -539,7 +555,7 @@ package (`tools/make_laya_tiny.py`, `tools/make_laya_ref.py`,
`tests/test_laya_tiny.py`), and the fixture behind the real gateway
(`tests/test_decision_serve.py`, `tests/test_jev_sdk.py`).
-### The next two
+### The next one
- **GLiNER2.5-Decide** (DeBERTa-v3 encoder, GLiNER2 heads): a second encoder
engine on the same contract. It needs the DeBERTa-v3 encoder (relative
@@ -547,10 +563,3 @@ package (`tools/make_laya_tiny.py`, `tools/make_laya_ref.py`,
its heads, its own rendering of a record into its input, and a
`resolve_model` rule for its checkpoint. `decide_serve.h`, the gateway and
the SDK tests stay as they are.
-- **Clef** (a joint schema head over Qwen3.8-27B, dense, with vision): the
- backbone is the qwen36 engine's. It would answer `DECIDE` in that engine's
- serve loop next to `SUBMIT`, announce `decide=1` without `chat=0` (the same
- process still chats), run the backbone over the rendered record and apply
- the head to its final hidden states. The record already carries what a
- schema head needs (every question with its typed options); a picture in the
- state would need the record to carry image parts, which today it does not.