blink v1.0

.dockerignore

@@ -0,0 +1,2 @@
+.git
+.cache

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,11 @@
+# blink server image: this repository's weights and runtime; Hugging Face libraries run in offline mode.
+#   hf download thegovind/<model> --revision <sha> --local-dir blink && cd blink
+#   docker build -t blink . && docker run --rm --gpus all -p 127.0.0.1:8000:8000 blink
+#   curl -s http://127.0.0.1:8000/healthz     # weights_verified, warmup.repeat_identical, kernels
+FROM pytorch/pytorch:2.13.0-cuda12.6-cudnn9-runtime
+ENV PIP_BREAK_SYSTEM_PACKAGES=1 PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
+RUN pip install "transformers==5.17.0" "flash-linear-attention==0.5.2" "accelerate>=1.0" "safetensors>=0.4" "huggingface_hub>=1.0"
+COPY . /blink
+ENV HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 HF_HUB_DISABLE_TELEMETRY=1
+EXPOSE 8000
+CMD ["python", "/blink/serve.py", "--model", "/blink", "--host", "0.0.0.0", "--port", "8000"]

LICENSE-Qwen

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE.md

@@ -0,0 +1,19 @@
+blink model weights: non-commercial research licence
+
+These weights are a modification of Qwen/Qwen3.5-4B (Apache License 2.0, Copyright 2026 Alibaba Cloud;
+the full licence text is in LICENSE-Qwen). The modification (fine-tuning with LoRA adapters merged into
+the weights, and a uniform average of three such fine-tuned checkpoints) was made by thegovind.
+
+The fine-tuning data included third-party datasets released under different terms, among them
+non-commercial (CC BY-NC 3.0 / 4.0) and share-alike (CC BY-SA 3.0 / 4.0) licences, and sources that
+state no licence (listed in README.md). Whether and how those terms apply to trained weights is unsettled.
+
+The author of the modification permits you to use, copy and run it for non-commercial research and
+evaluation only, provided this notice and LICENSE-Qwen are kept with every copy. No licence for commercial
+use is granted, and nothing here grants rights in any third-party data. You remain responsible for
+complying with the Apache License 2.0 for the Qwen base weights and with the terms of the upstream datasets.
+
+THE WEIGHTS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+
+This is a personal research release. It is not an official product of any company, and it is not
+affiliated with TypeSafe AI, Alibaba Cloud or the Qwen team.

README.md

@@ -0,0 +1,303 @@
+---
+license: other
+license_name: blink-research
+license_link: LICENSE.md
+base_model: Qwen/Qwen3.5-4B
+library_name: transformers
+pipeline_tag: text-classification
+inference: false
+tags:
+  - decision-model
+  - typed-decisions
+  - one-pass
+  - option-probabilities
+language:
+  - en
+---
+
+# blink-4b
+
+Send a text or JSON `state` and your questions: `choice` picks from up to 255 options, `noul` is yes/no,
+and `score` takes 2–10 ordered levels. Each question gets probabilities over its offered options from
+one forward pass, with no generated text. Long or large multi-question requests may use several batches.
+
+**Try it:** [Space demo](https://huggingface.co/spaces/thegovind/blink) — blink-4b and blink-mimo-9b run live ·
+[blink-4b](https://huggingface.co/thegovind/blink-4b) · [blink-27b](https://huggingface.co/thegovind/blink-27b) ·
+[blink-mimo-9b](https://huggingface.co/thegovind/blink-mimo-9b).
+
+*Personal research release by thegovind, not an official product of any company. No affiliation with TypeSafe AI,
+Xiaomi, Alibaba Cloud or the Qwen team. Weights are for non-commercial research; see [Licence](#licence).*
+
+## Results
+
+### JevBench: public-item development proxies
+
+| Model | Public-items proxy | Public hard (111) | Hard ECE | Probability TVD | Official JevBench v1.4 |
+|---|---:|---:|---:|---:|---:|
+| **blink-4b** | 76.5 | 80/111 | 0.067 | 0.226 | not submitted |
+| JevK5 v0.2.0 | 76.1 | 79/111 (own runtime: 82/111) | 0.068 | 0.220 | 62.0 |
+| Jev 1.13.0 | — | — | — | — | 63.3 |
+
+Both proxies use the same harness on public items. They aren't official JevBench scores or predictions: official scoring needs held-out, judge and sealed items. We claim no official score, rank or parity with Jev or JevK5.
+
+<details><summary>How to read the public-item numbers</summary>
+
+- On the public hard items, blink-4b got 80/111 and JevK5 got 79/111 in our runtime; JevK5's own runtime reports 82/111. We don't claim a hard-accuracy advantage. blink-4b's 95% Wilson interval is 0.631–0.796, before selection effects.
+- Speed comes from each row's own serial run. The proxy speed axis already applies JevBench's self-hosted adjustment.
+- Cost uses JevBench's 4B tariff ($0.03 per million input tokens) times measured tokens per decision; not a production bill.
+
+</details>
+
+### Decision Index 0.1 (archived edition)
+
+**Full suite: blink-4b 52.12 vs Jev 1.13.0 59.51.**
+
+| Model | Size class | Decision Index 0.1 | Skill | Breadth |
+|---|---|---:|---:|---:|
+| **blink-4b** (this model) | 4B | 52.12 | 36.04 | 34.18 |
+| Jev 1.13.0 | closed | 59.51 | 46.26 | 44.79 |
+| Jevfire | 27B | 55.74 | 40.86 | 39.45 |
+| JoshuaSP diffusiongemma (open-jev) | 26B-A4B | 55.56 | 40.84 | 39.19 |
+| Decider 35B-A3B | 35B-A3B | 54.34 | 39.37 | 37.99 |
+| Kev 9B | 9B | 50.48 | 32.96 | 30.54 |
+| Kev 4B | 4B | 47.43 | 28.86 | 25.67 |
+
+We ran the complete archived 0.1 suite: 132,422 requests across 37 benchmarks. The headline index averages 19 panel benchmarks. Comparison rows use the 2026-09-22 leaderboard snapshot. We ran the official kit's scorer locally; these aren't leaderboard submissions. The live [Decision Index](https://huggingface.co/spaces/multimodalart/jev-decision-index) moved to 0.2 on 2026-09-24, but the public kit can't build 0.2 yet.
+
+No Decision Index 0.2 result is reported for these models. Comparable shared-benchmark results require matched request subsets and the 0.2 metric transformations.
+
+On the archived 0.1 board, the best open entry with 3.5–5B served parameters was Kev 4B at 47.43; this model scored 52.12.
+
+| Area | blink-4b | Jev 1.13.0 |
+|---|---:|---:|
+| Knowledge & Reasoning | 49.1 | 68.8 |
+| Language Understanding | 61.0 | 62.3 |
+| Retrieval & Classification | 30.1 | 37.0 |
+| Tools & Automation | 70.2 | 73.6 |
+| Arts & Human Judgment | 50.2 | 56.2 |
+
+<details><summary>Per benchmark (19 panel benchmarks, 0.1)</summary>
+
+| Area | Benchmark | This model | Jev 1.13.0 |
+|---|---|---:|---:|
+| Knowledge | MMLU | 0.749 | 0.917 |
+| Knowledge | GPQA Diamond | 0.372 | 0.783 |
+| Knowledge | GSM8K | 0.579 | 0.799 |
+| Knowledge | CRUXEval | 0.472 | 0.730 |
+| Knowledge | CLadder | 0.637 | 0.726 |
+| Knowledge | ChessBench | 0.135 | 0.172 |
+| Language | ContractNLI | 0.761 | 0.717 |
+| Language | iSarcasmEval | 0.452 | 0.505 |
+| Language | VAST | 0.617 | 0.646 |
+| Retrieval | BRIGHT | 0.172 | 0.187 |
+| Retrieval | Amazon ESCI | 0.431 | 0.552 |
+| Tools | BFCL | 0.903 | 0.958 |
+| Tools | ToolRet | 0.412 | 0.450 |
+| Tools | RouterBench | 0.790 | 0.799 |
+| Arts | BPoMP | 0.847 | 0.906 |
+| Arts | Humicroedit | 0.605 | 0.619 |
+| Arts | POP909-CL | 0.034 | 0.181 |
+| Arts | cfcolor | 0.581 | 0.647 |
+| Arts | Habermas Machine | 0.443 | 0.459 |
+
+</details>
+
+## What we changed in the network
+
+| | What ships |
+|---|---|
+| Backbone | Qwen3.5-4B text model; 32 decoder layers (24 Gated DeltaNet, 8 full-attention), hidden 2560; 4,205,751,296 shipped text parameters |
+| Tuned | 32.5M LoRA parameters, merged before averaging |
+| Final weights | Uniform weight average ("soup") of T3, T4 step 300 and T4 final |
+
+T3/T4 also used KL anchors to the base model: its distributions on prompts whose teacher answers failed verification.
+
+**LoRA targets (rank 16, alpha 32, every language-model layer):** full-attention `q_proj`, `k_proj`, `v_proj`, `o_proj`;
+Gated DeltaNet `in_proj_qkv`, `in_proj_z`, `in_proj_a`, `in_proj_b`, `out_proj`; and every MLP's
+`gate_proj`, `up_proj`, `down_proj`. Token embeddings, all norms and `lm_head` stayed frozen.
+The trained adapters were merged into the text weights.
+
+Qwen3.5-4B is a vision-language model; this checkpoint ships only its text model. The vision encoder and multi-token-prediction (MTP) head were cut: 0 vision tensors, 0 MTP tensors.
+
+**The real cut is at readout:** no text generation. One prompt pass; next-token logits from only the
+offered option-label rows of `lm_head` (verified single tokens A–Z, then two-letter labels), computed in
+FP32 and softmaxed over those letters. The rest of the vocabulary is ignored.
+
+**Objective:** "calibration-oriented decision post-training" is plain supervised fine-tuning.
+Cross-entropy uses each row's target distribution: code-computed exact probabilities, probability
+targets in teacher-written questions kept after a blind re-solve by that same teacher agreed, and
+one-hot labels otherwise. For blink-4b, the base model's distributions on anchor rows are also targets. Choice and yes/no options and letter assignments are
+reshuffled each epoch; score levels keep their order. Jev's RLCD recipe isn't public; we didn't
+use or reproduce it. No RL or preference optimisation.
+
+## The climb
+
+DI-S is the 3,000-request sample. JevBench hard and ECE here are public-item numbers, not official scores.
+
+| Step | DI 0.1 | Public hard | Hard ECE | Why |
+|---|---:|---:|---:|---|
+| Qwen3.5-4B, zero-shot | 44.45 DI-S | 0.595 | 0.131 | Baseline before decision training. |
+| T1 (106.7k rows; lr 1e-4; 355 steps) | 53.15 DI-S | 0.559 | — | Public train splits plus exact-probability items lifted DI-S but hurt hard items; NLI/classification didn't transfer to long documents. |
+| T3 (23,156 question rows; lr 3e-5; 96 steps) | — | 0.649 | 0.089 | Restarted from base with worlds (including "can't tell"), exact probabilities, teacher-written docs, ~10% public replay and 7.6% base anchors. |
+| T4 (42,360 question rows; lr 4e-5; 472 steps) | — | 0.712 (step 300); 0.676 (final) | — | Added judge-style items; the earlier checkpoint did better on hard cases. |
+| **Soup (T3 + T4 step 300 + T4 final)** | 52.12 full | 0.721 | 0.067 | Averaged three checkpoints for hard accuracy and calibration; shipped. |
+
+**Tried, didn't keep:**
+- Distilling 27B answers into 4B didn't help on hard items.
+- A DI-focused 4B gained just +0.4 on DI-S.
+- Mixing JevK5 weights into the soup didn't help.
+- Qwen3.5-9B with the T1 recipe scored 54.5 DI-S, below our pre-set bar.
+
+## Use
+
+```python
+# pip install "torch==2.13.0" "transformers==5.17.0" "flash-linear-attention==0.5.2" "accelerate>=1.1.0" safetensors huggingface_hub
+import os, sys
+from huggingface_hub import hf_hub_download
+
+os.environ["BLINK_MODEL"] = "thegovind/blink-4b"
+os.environ["BLINK_REVISION"] = "v1.0"
+sys.path.insert(0, os.path.dirname(hf_hub_download("thegovind/blink-4b", "blink.py", revision="v1.0")))
+import blink
+
+out = blink.decide(
+    "Order #4411 arrived with a cracked screen. I want my money back, not another one.",
+    {
+        "intent": {
+            "type": "choice",
+            "instructions": "What does the customer want?",
+            "criteria": {"refund": "Money back", "replacement": "A new unit", "info": "Information only"},
+        },
+        "urgent": {"type": "noul", "instructions": "Does this need a reply today?"},
+        "anger": {"type": "score", "instructions": "How upset is the customer?", "criteria": ["calm", "annoyed", "angry"]},
+    },
+)
+print(out["answers"]["intent"]["probabilities"])
+```
+
+## Run it as a server
+
+`serve.py` accepts Jev-compatible `POST /v1/systemone` (`{state, questions}` → `{answers, usage}`);
+JevBench's stock `typesafe` adapter and the Decision Index kit's `http` engine use this format.
+`GET /healthz` reports startup checks.
+
+```sh
+pip install "torch==2.13.0" "transformers==5.17.0" "flash-linear-attention==0.5.2" "accelerate>=1.1.0" safetensors huggingface_hub
+hf download thegovind/blink-4b --revision v1.0 --local-dir blink-4b
+python blink-4b/serve.py --model ./blink-4b --port 8000
+```
+
+In another terminal: `curl -s http://127.0.0.1:8000/healthz`.
+
+**Or use Docker** from the downloaded folder:
+
+```sh
+cd blink-4b
+docker build -t blink-4b . && docker run --rm --gpus all -p 127.0.0.1:8000:8000 blink-4b
+```
+
+<details><summary>Health, limits and weights</summary>
+
+- `/healthz` reports `weights_verified` (weight, config and tokenizer files listed in `weights.sha256`
+  are hashed before serving; a mismatch stops startup), `warmup.repeat_identical` (two matching warm-up
+  answers), `kernels` (fast path or slower fallback without flash-linear-attention), `versions` and `hub_offline`.
+- Limits: 255 options per choice, 2–10 score levels, 131,072 input tokens per question and 512 questions
+  per request. Over-limit requests get HTTP 422 with the reason; nothing is truncated.
+- Requests run one at a time. Questions are batched; each batch takes one forward pass (large requests
+  can take more than one). Serving the downloaded folder or Docker image enables Hugging Face offline
+  mode before model loading (`hub_offline: true`). The server doesn't otherwise restrict network access.
+- blink-4b weights are 8.4 GB in bf16. Long prompts need more memory.
+
+</details>
+
+<details><summary>Model and probability readout</summary>
+
+| | |
+|---|---|
+| Base | [Qwen/Qwen3.5-4B](https://huggingface.co/Qwen/Qwen3.5-4B) (Apache-2.0), text weights only |
+| Adaptation | LoRA (r16, α32) on attention, Gated DeltaNet and MLP projections; uniform average of three merged checkpoints from two runs |
+| Readout | Verified single-token labels (A–Z, then two-letter labels); FP32 softmax of next-token logits / T over the offered labels |
+| Temperature | 1.0 (not fitted; see evaluation notes) |
+| Input limit | 131,072 tokens per question; longest evaluated prompt: 37,906 tokens; longer inputs are refused, never truncated |
+| Runtime | `blink.py` builds prompts and reads out probabilities for text decisions |
+
+These are option-conditional model probabilities, not certified chances of being right. Calibration can shift
+across tasks, domains and option sets. For `choice`, `confidence = (p_max − 1/K)/(1 − 1/K)` measures
+concentration, not correctness. For `score`, `score` is the expected 0-based level and `choice` is the
+most likely level.
+
+</details>
+
+<details><summary>Training and data</summary>
+
+### How it was trained
+
+| Stage | Question rows | Mix |
+|---|---:|---|
+| T3 | 23,156 | 11,352 decision worlds · 3,741 teacher-written question rows · 2,579 exact-probability worlds · 2,221 public-source (~10%) · 1,763 base-model anchors (7.6%) · 1,500 program-generated reasoning |
+| T4 | 42,360 | 12,000 decision worlds · 7,860 teacher-written question rows · 7,000 judge-style · 6,220 exact-probability worlds · 3,500 base-model anchors (8.3%) · 3,000 program-generated reasoning · 2,780 public-source |
+
+T4 judge-style: 3,000 GSM8K-train solution checks, 2,500 Dolly-15k routing, 1,500 program-answer checks.
+
+The released weights average three checkpoints fine-tuned from the base: T3 (lr 3e-5, 96 steps), T4 at step 300 and T4 at its final step 472 (lr 4e-5). The base-model anchor targets come from the base's own distributions on authored prompts whose teacher answers failed verification. Qwen3.8-27B wrote the teacher documents and their typed questions.
+
+### Data sources and licences
+
+| Source | Licence |
+|---|---|
+| MMLU auxiliary train, MMLU-Pro, CommonsenseQA, GSM8K | MIT |
+| AQuA-RAT, Amazon ESCI | Apache-2.0 |
+| MedMCQA | Apache-2.0 (dataset card) |
+| SuperGPQA | ODC-BY |
+| WANLI, ContractNLI, BANKING77, GPQA | CC BY 4.0 |
+| ARC | CC BY-SA 4.0 |
+| BoolQ, Dolly-15k | CC BY-SA 3.0 |
+| ANLI | CC BY-NC 4.0 |
+| SciQ | CC BY-NC 3.0 |
+| iSarcasmEval | MIT (upstream repository licence) |
+| VAST, Humicroedit, OpenBookQA | None stated by source |
+| Our code-generated worlds and teacher-written documents (Qwen3.8-27B) | See LICENSE.md |
+
+These are source-repository licences; they don't settle rights in every underlying text.
+
+</details>
+
+<details><summary>Evaluation notes and limits</summary>
+
+### Evaluation notes
+
+- **Scorer parity.** `blink.py` and the evaluation scorer matched prompts, labels and argmaxes on 296 requests (max |Δp| < 1e-7). At a pinned revision from a fresh install, JevBench's stock `typesafe` adapter reproduced public-item results byte for byte (easy 48/48, standard 71/72, hard 80/111); the Decision Index kit's `http` engine scored DI-S 50.16 versus 50.08 in-process; its per-request timer on 1,000 random suite requests served serially measured a 66.4 ms median over HTTP versus 65.2 ms in-process.
+- **Selection.** We reused DI-S, the official kit's 3,000-request sample of the 0.1 suite, to pick the prompt format and candidate checkpoints. We fixed blink-4b using JevBench development proxies before its full-suite run. It scored 52.29 on the 129,422 requests outside DI-S.
+- **Training overlap.** Public train splits also used by the 0.1 index: ContractNLI, iSarcasmEval, VAST, Amazon ESCI, Humicroedit, GSM8K (train split; solution-checking items). We also used ANLI and BANKING77 train splits; they're in the 0.1 suite but outside its index, and both are in the 0.2 panel. No identical suite test row was used; the overlap audit below covers shared passages.
+- **Partitions.** Public-source data included training and development partitions, plus 281 MMLU-Pro test-partition questions (not in the 0.1 suite, but in the 0.2 panel, so don't score these weights on 0.2 MMLU-Pro) and 2 GPQA extended-set questions outside GPQA Diamond.
+- **Final-mixture audit.** Rechecked every question row (including teacher-written rows, plus base-model anchors) against the complete 0.1 suite (132,422 requests) and JevBench's 231 public items. The checks used normalised text of at least 30 characters and 13-word passages. No public JevBench item matched; no chess position is shared.
+- **Suite overlap.** No training row repeats suite content. All 36 flags were the fixed BANKING77 prompt template.
+- **Audit limits.** Semantic or pretraining overlap can't be ruled out; private JevBench items weren't available to check.
+- **Generated reasoning.** Our programs computed the labels for CRUXEval-style code and CLadder-style causal questions; no items from those benchmarks were used. We didn't reuse the suite's GSM8K distractors.
+- **Teacher documents.** We kept Qwen3.8-27B's documents only if a fresh blind solve by that same teacher agreed with the answer. That's an agreement filter, not independent verification.
+- The repo ships no benchmark items, GPQA text, JevBench items or teacher traces.
+- **JevBench selection.** We scored all 231 public items on each candidate checkpoint and used JevK5's 65 hand-written hard items (Apache-2.0) as a second selection set. None went into training; these are development results.
+- **Temperature.** A split held out from T4 suggested T = 0.82, with negligible gain. But 166 of its 401 items were in T3 training, so it isn't held out from the released average. We kept T = 1.0 without fitting it.
+- **One-time lockbox.** We read held-out authored items from domains unseen in any of the three checkpoints' training data (same generator families, not JevBench's sealed set) once: accuracy 0.861 and ECE 0.026 over 396 items.
+
+### Limits
+
+- English-centric. Training included Arabic iSarcasmEval rows; on the 0.1 suite, Arabic task A scored 0.313 and task C pairs 0.645. Broader multilingual performance hasn't been established.
+- Doesn't chat or explain answers.
+- Text in the state can sway the answer.
+- Date arithmetic and long policies are its weakest cases.
+
+</details>
+
+## Licence
+
+Qwen/Qwen3.5-4B is Apache-2.0 (`LICENSE-Qwen`). The blink weights are for **non-commercial research and evaluation
+only** (`LICENSE.md`); commercial use isn't licensed. Training used non-commercial, share-alike and unlicensed
+sources (see the table above). It's unsettled whether their terms reach the weights, so check upstream terms too.
+`blink.py`, `serve.py` and the Dockerfile are Apache-2.0.
+
+<details><summary>Credits</summary>
+
+The Qwen team (base models). SemIf (MIT) for the evidence/criterion/options prompt layout. The Decision Index kit (MIT) and JevBench (MIT) for evaluation. JevK5 (Apache-2.0) for its hand-written hard items, used for evaluation only.
+
+</details>

blink.py

@@ -0,0 +1,623 @@
+"""blink — one-pass typed decisions.
+
+A request is a `state` plus a map of typed questions. Every question is rendered
+independently with the fixed "semif" template the model was trained on, the questions run
+as right-padded prefills (packed into batches of at most BLINK_TOKEN_BUDGET padded tokens,
+all inside one GPU call), and the answer is read from the next-token distribution over the
+offered option labels. No tokens are generated.
+
+Engines (BLINK_ENGINE): "torch" runs the model; "replay" serves label logits the real
+model produced for the bundled examples (hosting without the model); "hybrid" serves those
+recordings for the bundled examples and runs the model for everything else; "mock" is a
+deterministic stand-in with fabricated numbers (BLINK_MOCK=1 also selects it). By default:
+hybrid when CUDA and a recording are both present, torch when only CUDA is, replay otherwise.
+
+BLINK_MODELS="repo[@revision],repo2" serves several models side by side (decide(..., model=...));
+the default model's recording is replay.json, another model's replay-<repo name>.json, and a
+recording is only used by the model that made it.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+import json
+import math
+import os
+import re
+import string
+import time
+
+# --- constants the deployment sets -------------------------------------------------
+
+MODEL_ID = os.environ.get("BLINK_MODEL") or "thegovind/blink-4b"
+MODEL_ID_27B = "thegovind/blink-27b"
+MODEL_REVISION = os.environ.get("BLINK_REVISION") or None
+
+
+def _model_specs() -> list[tuple[str, str | None]]:
+    """BLINK_MODELS serves several models side by side: comma-separated "repo" or "repo@revision",
+    the first one the default. Unset, the single BLINK_MODEL / BLINK_REVISION pair is served."""
+    specs = []
+    for item in os.environ.get("BLINK_MODELS", "").split(","):
+        repo, _, rev = item.strip().partition("@")
+        if repo.strip():
+            specs.append((repo.strip(), rev.strip() or None))
+    return specs or [(MODEL_ID, MODEL_REVISION)]
+
+
+MODEL_SPECS = _model_specs()
+MODEL_ID, MODEL_REVISION = MODEL_SPECS[0]
+
+# Default release temperature: 1.0, not fitted; callers may override it.
+TEMPERATURE = float(os.environ.get("BLINK_TEMPERATURE", "1.0"))
+
+MAX_OPTIONS = 255
+MAX_QUESTIONS = 512
+MAX_INPUT_TOKENS = int(os.environ.get("BLINK_MAX_INPUT_TOKENS", "131072"))  # as evaluated
+TOKEN_BUDGET = int(os.environ.get("BLINK_TOKEN_BUDGET", "32768"))  # padded tokens per forward
+GPU_DURATION = int(os.environ.get("BLINK_GPU_DURATION", "60"))
+
+SYSTEM = (
+    "Apply the supplied criterion to the supplied evidence. Choose exactly one listed option. "
+    "Respond with only its uppercase letter, with no explanation or reasoning."
+)
+
+LABEL_POOL = list(string.ascii_uppercase) + [
+    "".join(p) for p in itertools.product(string.ascii_uppercase, repeat=2)
+]
+GENERIC_KEY = re.compile(r"^(?:[A-Za-z]{1,2}|option[_ ]?\d+|opt\d+|\d+)$")
+
+MOCK = os.environ.get("BLINK_MOCK", "") not in ("", "0", "false", "False")
+ENGINE = "mock" if MOCK else os.environ.get("BLINK_ENGINE", "").strip().lower()
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPLAY_PATH = os.environ.get("BLINK_REPLAY", os.path.join(HERE, "replay.json"))
+
+
+def replay_path(model_id: str | None = None) -> str:
+    """The default model's recording is replay.json (or BLINK_REPLAY); any other served model's
+    is replay-<repo name>.json beside this file."""
+    if model_id is None or model_id == MODEL_ID:
+        return REPLAY_PATH
+    return os.path.join(HERE, f"replay-{model_id.rstrip('/').split('/')[-1]}.json")
+
+
+class BlinkError(ValueError):
+    """A request that cannot be rendered."""
+
+
+class ReplayMiss(BlinkError):
+    """Replay mode has no recorded output for this request."""
+
+
+# --- rendering (pure python; the model was trained on exactly this) -----------------
+
+
+def text(x) -> str:
+    if x is None:
+        return ""
+    if isinstance(x, str):
+        return x
+    return json.dumps(x, ensure_ascii=False, indent=2)
+
+
+def option_text(key, desc) -> str:
+    k = str(key)
+    if desc is None or (isinstance(desc, str) and not desc.strip()):
+        return k
+    d = text(desc)
+    if GENERIC_KEY.match(k) or k.strip().lower() == d.strip().lower():
+        return d
+    return f"{k}: {d}"
+
+
+def question_options(q: dict) -> list[tuple[str, str]]:
+    """[(option_key, display_text)] in request order."""
+    qtype = q.get("type")
+    crit = q.get("criteria")
+    if qtype == "choice":
+        if isinstance(crit, dict):
+            items = [(str(k), option_text(k, v)) for k, v in crit.items()]
+        elif isinstance(crit, list):
+            items = [(str(k), str(k)) for k in crit]
+        else:
+            raise BlinkError("choice needs criteria")
+    elif qtype == "noul":
+        t = f = None
+        if isinstance(crit, dict):
+            t = crit.get("true", crit.get("yes"))
+            f = crit.get("false", crit.get("no"))
+        items = [
+            ("yes", "Yes" + (f" — {text(t)}" if t else "")),
+            ("no", "No" + (f" — {text(f)}" if f else "")),
+        ]
+    elif qtype == "score":
+        if not isinstance(crit, list) or not 2 <= len(crit) <= 10:
+            raise BlinkError("a score takes 2 to 10 levels")
+        items = [
+            (str(i), f"Level {i}: {text(c)}" if c is not None else f"Level {i}")
+            for i, c in enumerate(crit)
+        ]
+    else:
+        raise BlinkError(f"unsupported question type {qtype!r}")
+    keys = [k for k, _ in items]
+    if len(set(keys)) != len(keys):
+        raise BlinkError("duplicate option keys")
+    if not 1 <= len(items) <= MAX_OPTIONS:
+        raise BlinkError(f"{len(items)} options per choice; supported 1-{MAX_OPTIONS}")
+    return items
+
+
+def user_message(state, q: dict, labels: list[str], items: list[tuple[str, str]]) -> str:
+    return json.dumps(
+        {
+            "evidence": state,
+            "criterion": text(q.get("instructions")).strip(),
+            "options": [
+                {"letter": lab, "description": d} for lab, (_, d) in zip(labels, items)
+            ],
+        },
+        ensure_ascii=False,
+    )
+
+
+def validate(questions) -> None:
+    if not isinstance(questions, dict) or not questions:
+        raise BlinkError("questions must be a non-empty object")
+    if len(questions) > MAX_QUESTIONS:
+        raise BlinkError(f"{len(questions)} questions; supported 1-{MAX_QUESTIONS}")
+    for qkey, q in questions.items():
+        if not isinstance(q, dict):
+            raise BlinkError(f"question {qkey!r} must be an object")
+        question_options(q)
+
+
+def as_state(state):
+    """A state that looks like JSON is passed through as JSON; anything else is text."""
+    if not isinstance(state, str) or not state.strip().startswith(("{", "[")):
+        return state
+    try:
+        return json.loads(state)
+    except json.JSONDecodeError:
+        return state
+
+
+# --- answer assembly ----------------------------------------------------------------
+
+
+def answer_for(q: dict, keys: list[str], probs: list[float]) -> dict:
+    p = {k: v for k, v in zip(keys, probs)}
+    z = sum(p.values()) or 1.0
+    p = {k: v / z for k, v in p.items()}
+    qtype = q["type"]
+    if qtype == "choice":
+        order = list(p)
+        best = max(order, key=lambda k: (p[k], -order.index(k)))
+        K = len(order)
+        conf = (p[best] - 1 / K) / (1 - 1 / K) if K > 1 else 1.0
+        return {"type": "choice", "choice": best, "probabilities": p, "confidence": conf}
+    if qtype == "noul":
+        return {"type": "noul", "noul": p["yes"], "probabilities": p}
+    levels = [str(i) for i in range(len(q["criteria"]))]
+    ev = sum(int(k) * p[k] for k in levels)
+    return {
+        "type": "score",
+        "score": ev,
+        "probabilities": {k: p[k] for k in levels},
+        "legend": {k: text(q["criteria"][int(k)]) for k in levels},
+        "choice": max(levels, key=lambda k: (p[k], -int(k))),
+    }
+
+
+def softmax(logits: list[float], temperature: float) -> list[float]:
+    z = [v / temperature for v in logits]
+    m = max(z)
+    e = [math.exp(v - m) for v in z]
+    s = sum(e)
+    return [v / s for v in e]
+
+
+# --- mock engine --------------------------------------------------------------------
+
+_WORD = re.compile(r"[a-z0-9']+")
+_STOP = frozenset(
+    "a an the of to and or is are was were be been it its this that for in on at "
+    "with as by from not no yes if then than there here we you they i".split()
+)
+
+
+def _terms(s: str) -> set[str]:
+    return {w for w in _WORD.findall(s.lower()) if w not in _STOP and len(w) > 2}
+
+
+class MockEngine:
+    """Deterministic stand-in: lexical overlap plus a stable pseudo-random jitter.
+
+    Values are fabricated. They exist so the interface can be exercised without a GPU.
+    A caller may pass `bias` to shape a bundled demo; the real engine ignores it.
+    """
+
+    name = "mock"
+    temperature = TEMPERATURE
+
+    def __init__(self, model_id: str = MODEL_ID):
+        self.model_id = model_id
+        # every served model gets its own fabricated numbers; the default keeps the historic ones
+        self._salt = "" if model_id == MODEL_ID else f"|{model_id}"
+
+    def logits(self, state, questions: dict, bias: dict | None = None) -> tuple[dict[str, list[float]], int]:
+        evidence = _terms(text(state))
+        bias = bias or {}
+        out, n_tokens = {}, 0
+        for qkey, q in questions.items():
+            items = question_options(q)
+            labels = LABEL_POOL[: len(items)]
+            prompt = SYSTEM + user_message(state, q, labels, items)
+            n_tokens += max(1, len(prompt) // 4)
+            crit = _terms(text(q.get("instructions")))
+            hint = bias.get(qkey) or {}
+            row = []
+            for i, (key, disp) in enumerate(items):
+                opt = _terms(disp)
+                overlap = len(opt & evidence) / (len(opt) ** 0.5 + 1.0)
+                cue = len(opt & crit) / (len(crit) ** 0.5 + 1.0)
+                seed = f"{text(state)}|{text(q.get('instructions'))}|{key}|{i}{self._salt}".encode()
+                jitter = int.from_bytes(hashlib.blake2b(seed, digest_size=4).digest(), "big")
+                row.append(
+                    2.6 * overlap
+                    + 1.1 * cue
+                    + 1.9 * (jitter / 2**32)
+                    - 0.5 * i / len(items)
+                    + float(hint.get(key, 0.0))
+                )
+            out[qkey] = row
+        return out, n_tokens
+
+
+# --- replay engine ------------------------------------------------------------------
+
+
+def request_key(state, questions: dict) -> str:
+    """Stable key for a request. Question and option order are part of the request."""
+    if isinstance(state, str):
+        state = state.replace("\r\n", "\n").strip()
+    blob = json.dumps({"state": state, "questions": questions}, ensure_ascii=False, separators=(",", ":"))
+    return hashlib.sha256(blob.encode("utf-8")).hexdigest()[:32]
+
+
+class ReplayEngine:
+    """Label logits the trained model produced for the bundled examples, recorded with
+    TorchEngine. Temperature and answer assembly still run live."""
+
+    name = "replay"
+
+    def __init__(self, path: str = REPLAY_PATH, temperature: float = TEMPERATURE):
+        with open(path, encoding="utf-8") as fh:
+            data = json.load(fh)
+        self.model_id = data["model"]
+        self.hardware = data.get("hardware", "")
+        self.temperature = float(temperature)
+        self.cache = data["requests"]
+        self.last = None
+
+    def logits(self, state, questions: dict, bias: dict | None = None) -> tuple[dict[str, list[float]], int]:
+        del bias
+        hit = self.cache.get(request_key(state, questions))
+        if hit is None:
+            raise ReplayMiss(
+                "Edited input. This page only has saved runs for the built-in examples and presets. "
+                "Pick one of those, or run blink.py yourself to decide on any text."
+            )
+        self.last = hit
+        return {k: list(v) for k, v in hit["logits"].items()}, int(hit["input_tokens"])
+
+
+# --- torch engine -------------------------------------------------------------------
+
+
+def _gpu(duration: int):
+    """spaces.GPU when running on ZeroGPU, a no-op decorator anywhere else."""
+    try:
+        import spaces
+    except Exception:
+        return lambda fn: fn
+    try:
+        return spaces.GPU(duration=duration)
+    except Exception:
+        return spaces.GPU
+
+
+def _on_zero_gpu() -> bool:
+    try:
+        from spaces.config import Config
+
+        return bool(Config.zero_gpu)
+    except Exception:
+        return os.environ.get("SPACES_ZERO_GPU", "").lower() in ("1", "true")
+
+
+# Live engines by id. The GPU function looks its engine up here instead of receiving it as an
+# argument: on ZeroGPU the call runs in a worker process where only module-level state carries the
+# real weights, and an argument would arrive as a copy.
+_LIVE: dict = {}
+
+
+class TorchEngine:
+    """Prefill-only readout over the offered labels, all questions of a request in one GPU call."""
+
+    name = "torch"
+
+    def __init__(self, model_id: str = MODEL_ID, revision=None, temperature: float = TEMPERATURE,
+                 token_budget: int = TOKEN_BUDGET):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        self.model_id = model_id
+        self.temperature = float(temperature)
+        self.token_budget = int(token_budget)
+        self.tok = AutoTokenizer.from_pretrained(model_id, revision=revision)
+        load = dict(revision=revision, dtype=torch.bfloat16, attn_implementation="sdpa")
+        if _on_zero_gpu():
+            # ZeroGPU: load on the host, then place on cuda at module level (emulated until
+            # a @spaces.GPU call attaches a real device).
+            self.model = AutoModelForCausalLM.from_pretrained(model_id, **load).to("cuda")
+        else:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            self.model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, **load)
+        self.model.eval()
+        self.pad_id = self.tok.pad_token_id if self.tok.pad_token_id is not None else 0
+        self.labels, self.label_ids = self._verify_labels()
+        self.key = id(self)
+        _LIVE[self.key] = self
+
+    def _wrap(self, user: str) -> str:
+        return self.tok.apply_chat_template(
+            [{"role": "system", "content": SYSTEM}, {"role": "user", "content": user}],
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+
+    def _verify_labels(self) -> tuple[list[str], list[int]]:
+        """Keep labels that are one token at the assistant boundary and decode back to themselves."""
+        probe = self._wrap("x")
+        base = self.tok(probe, add_special_tokens=False)["input_ids"]
+        labels, ids = [], []
+        for lab in LABEL_POOL:
+            t = self.tok(probe + lab, add_special_tokens=False)["input_ids"]
+            if (
+                len(t) == len(base) + 1
+                and t[: len(base)] == base
+                and self.tok.decode(t[-1:]) == lab
+            ):
+                labels.append(lab)
+                ids.append(t[-1])
+            if len(labels) >= MAX_OPTIONS:
+                break
+        if len(set(ids)) != len(ids):
+            raise BlinkError("label token ids collide")
+        if len(labels) < 26 or labels[:26] != list(string.ascii_uppercase):
+            raise BlinkError(f"only {len(labels)} verified single-token labels")
+        return labels, ids
+
+    def render(self, state, questions: dict):
+        work = []
+        for qkey, q in questions.items():
+            items = question_options(q)
+            if len(items) > len(self.labels):
+                raise BlinkError(f"{len(items)} options per choice; {len(self.labels)} labels verified")
+            labels = self.labels[: len(items)]
+            prompt = self._wrap(user_message(state, q, labels, items))
+            ids = self.tok(prompt, add_special_tokens=False)["input_ids"]
+            if len(ids) > MAX_INPUT_TOKENS:
+                raise BlinkError(
+                    f"question {qkey!r} renders to {len(ids)} tokens, over the maximum context length "
+                    f"of {MAX_INPUT_TOKENS}"
+                )
+            work.append(
+                {
+                    "qkey": qkey,
+                    "keys": [k for k, _ in items],
+                    "ids": ids,
+                    "cand": self.label_ids[: len(items)],
+                }
+            )
+        return work
+
+    def logits(self, state, questions: dict, bias: dict | None = None) -> tuple[dict[str, list[float]], int]:
+        del bias  # demo-only shaping; the trained model reads the evidence instead
+        work = self.render(state, questions)
+        rows, self.last_model_ms = _forward(self.key, [w["ids"] for w in work], [w["cand"] for w in work])
+        return (
+            {w["qkey"]: r for w, r in zip(work, rows)},
+            sum(len(w["ids"]) for w in work),
+        )
+
+
+def _batches(lengths: list[int], budget: int):
+    """Shortest first; a batch closes when (longest x count) would pass the padded-token budget.
+    A sequence longer than the budget runs alone."""
+    order = sorted(range(len(lengths)), key=lambda i: lengths[i])
+    batch, longest = [], 0
+    for i in order:
+        grown = max(longest, lengths[i])
+        if batch and grown * (len(batch) + 1) > budget:
+            yield batch
+            batch, grown = [], lengths[i]
+        batch.append(i)
+        longest = grown
+    if batch:
+        yield batch
+
+
+@_gpu(GPU_DURATION)
+def _forward(key: int, seqs: list[list[int]], cands: list[list[int]]):
+    """Right-padded maskless prefill; every layer is causal, so padding cannot reach the
+    last real position. Label rows of lm_head are applied in FP32."""
+    import torch
+
+    engine = _LIVE[key]
+    model = engine.model
+    device = next(model.parameters()).device
+    head = model.lm_head.weight
+    out: list = [None] * len(seqs)
+    t0 = time.perf_counter()
+    with torch.no_grad():
+        for b in _batches([len(s) for s in seqs], getattr(engine, "token_budget", TOKEN_BUDGET)):
+            L = max(len(seqs[i]) for i in b)
+            ids = torch.full((len(b), L), engine.pad_id, dtype=torch.long)
+            for r, i in enumerate(b):
+                ids[r, : len(seqs[i])] = torch.tensor(seqs[i], dtype=torch.long)
+            ids = ids.to(device)
+            h = model.model(input_ids=ids, use_cache=False).last_hidden_state
+            last = torch.tensor([len(seqs[i]) - 1 for i in b], device=device)
+            h = h[torch.arange(len(b), device=device), last].float()
+            for r, i in enumerate(b):
+                w = head[torch.tensor(cands[i], device=device)].float()
+                out[i] = (w @ h[r]).tolist()
+    return out, round((time.perf_counter() - t0) * 1000, 1)
+
+
+# --- hybrid engine ------------------------------------------------------------------
+
+
+class HybridEngine:
+    """Recorded outputs for the bundled examples (instant, no GPU), the live model for
+    everything else. The torch engine is built eagerly: ZeroGPU wants weights placed at startup."""
+
+    name = "hybrid"
+
+    def __init__(self, replay: "ReplayEngine | None", live: "TorchEngine"):
+        self.replay, self.live = replay, live
+        self.model_id = live.model_id
+        self.temperature = live.temperature
+        self.hardware = replay.hardware if replay is not None else ""
+        self.last_source = None
+        self.last = None
+
+    def logits(self, state, questions: dict, bias: dict | None = None,
+               prefer: str = "live") -> tuple[dict[str, list[float]], int]:
+        if (
+            prefer == "saved"
+            and self.replay is not None
+            and self.replay.cache.get(request_key(state, questions)) is not None
+        ):
+            self.last_source = "replay"
+            out = self.replay.logits(state, questions)
+            self.last = self.replay.last
+            return out
+        self.last_source = "torch"
+        return self.live.logits(state, questions)
+
+
+# --- public entry point -------------------------------------------------------------
+
+_ENGINE = None  # the default model's engine (tests inject one here)
+_ENGINES: dict = {}  # every other served model's engine, by id
+
+
+def _cuda() -> bool:
+    try:
+        import torch
+    except Exception:
+        return False
+    return bool(torch.cuda.is_available())
+
+
+def engine_kind() -> str:
+    if ENGINE in ("mock", "replay", "torch", "hybrid"):
+        return ENGINE
+    recorded = os.path.exists(REPLAY_PATH)
+    if _cuda():
+        return "hybrid" if recorded else "torch"
+    return "replay" if recorded else "torch"
+
+
+def models() -> list[str]:
+    """Model ids this deployment serves, the default first."""
+    return [m for m, _ in MODEL_SPECS]
+
+
+def _matching_replay(model_id: str):
+    """The model's recording, only if that same model made it: a saved run must be what the live
+    model would answer."""
+    path = replay_path(model_id)
+    if not os.path.exists(path):
+        return None
+    rec = ReplayEngine(path, TEMPERATURE)
+    return rec if rec.model_id == model_id else None
+
+
+def _build(model_id: str):
+    revision = dict(MODEL_SPECS).get(model_id)
+    kind = engine_kind()
+    if kind == "mock":
+        return MockEngine(model_id)
+    if kind == "replay":
+        return ReplayEngine(replay_path(model_id), TEMPERATURE)
+    if kind == "hybrid":
+        return HybridEngine(_matching_replay(model_id), TorchEngine(model_id, revision, TEMPERATURE))
+    return TorchEngine(model_id, revision, TEMPERATURE)
+
+
+def engine(model: str | None = None):
+    global _ENGINE
+    mid = model or MODEL_ID
+    if mid not in dict(MODEL_SPECS):
+        raise BlinkError(f"unknown model {mid!r}; this deployment serves {', '.join(models())}")
+    if mid == MODEL_ID:
+        if _ENGINE is None:
+            _ENGINE = _build(mid)
+        return _ENGINE
+    if mid not in _ENGINES:
+        _ENGINES[mid] = _build(mid)
+    return _ENGINES[mid]
+
+
+def warm() -> list:
+    """Build every served model's engine now: ZeroGPU wants weights placed at startup."""
+    return [engine(m) for m in models()]
+
+
+def decide(state, questions: dict, temperature: float | None = None, bias: dict | None = None,
+           prefer: str = "live", model: str | None = None) -> dict:
+    """{state, questions} -> {answers, meta}. One forward pass, zero generated tokens.
+
+    `bias` shapes the mock engine so the bundled examples read realistically without a
+    GPU. It is discarded by the trained model. `prefer="saved"` lets the hybrid engine answer
+    a bundled example from its recording (used for the first page render); every other call
+    runs the model. `model` picks one of models() (default: the first).
+    """
+    validate(questions)
+    eng = engine(model)
+    T = float(temperature if temperature is not None else eng.temperature)
+    if T <= 0:
+        raise BlinkError("temperature must be positive")
+    t0 = time.perf_counter()
+    if isinstance(eng, HybridEngine):
+        raw, n_tokens = eng.logits(state, questions, bias, prefer=prefer)
+    else:
+        raw, n_tokens = eng.logits(state, questions, bias)
+    answers = {}
+    for qkey, q in questions.items():
+        keys = [k for k, _ in question_options(q)]
+        answers[qkey] = answer_for(q, keys, softmax(raw[qkey], T))
+    latency_ms = round((time.perf_counter() - t0) * 1000, 1)
+    source = getattr(eng, "last_source", None) or eng.name
+    meta = {
+        "model": getattr(eng, "model_id", MODEL_ID),
+        "engine": source,
+        "temperature": T,
+        "input_tokens": n_tokens,
+        "generated_tokens": 0,
+        "latency_ms": latency_ms,
+    }
+    if source == "replay":
+        meta["latency_ms"] = float(eng.last["latency_ms"])
+        if eng.hardware:
+            meta["recorded_on"] = eng.hardware
+    elif source == "torch":
+        model_ms = getattr(getattr(eng, "live", eng), "last_model_ms", None)
+        if model_ms is not None:
+            meta["model_ms"] = model_ms  # forward passes only; excludes any wait for a device
+    return {"answers": answers, "meta": meta}

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,83 @@
+{
+  "architectures": [
+    "Qwen3_5ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_output_gate": true,
+  "bos_token_id": null,
+  "dtype": "bfloat16",
+  "eos_token_id": 248044,
+  "full_attention_interval": 4,
+  "head_dim": 256,
+  "hidden_act": "silu",
+  "hidden_size": 2560,
+  "initializer_range": 0.02,
+  "intermediate_size": 9216,
+  "layer_types": [
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention"
+  ],
+  "linear_conv_kernel_dim": 4,
+  "linear_key_head_dim": 128,
+  "linear_num_key_heads": 16,
+  "linear_num_value_heads": 32,
+  "linear_value_head_dim": 128,
+  "mamba_ssm_dtype": "float32",
+  "max_position_embeddings": 262144,
+  "mlp_only_layers": [],
+  "model_type": "qwen3_5_text",
+  "mtp_num_hidden_layers": 1,
+  "mtp_use_dedicated_embeddings": false,
+  "num_attention_heads": 16,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 4,
+  "pad_token_id": null,
+  "partial_rotary_factor": 0.25,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "mrope_interleaved": true,
+    "mrope_section": [
+      11,
+      11,
+      10
+    ],
+    "partial_rotary_factor": 0.25,
+    "rope_theta": 10000000,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.17.0",
+  "use_cache": true,
+  "vocab_size": 248320
+}

eval/decision-index-0.1-full.json

@@ -0,0 +1,1080 @@
+{
+ "engine": "blink-4b",
+ "generated_utc": "2026-09-24T09:01:21+00:00",
+ "suite": {
+  "requests": 132422,
+  "scoreable": 131980,
+  "excluded": 442,
+  "benchmarks": 37,
+  "rows_sha256": "750d353a3a83af615c67cfe9752e005bf09e6c28d9c4ba28d3a9f57ba8536cfd"
+ },
+ "completed": 132422,
+ "complete": true,
+ "counts": {
+  "ok": 132422
+ },
+ "latency_ms": {
+  "median": 33.4,
+  "p95": 765.3,
+  "mean": 169.5
+ },
+ "decision_index": 52.12,
+ "scores": {
+  "balanced_raw": 52.12,
+  "balanced_skill": 36.04,
+  "breadth_skill": 34.18
+ },
+ "areas": [
+  {
+   "id": "knowledge",
+   "label": "Knowledge & Reasoning",
+   "raw": 0.4907,
+   "skill": 0.3016,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 6,
+   "benchmarks": [
+    24,
+    25,
+    30,
+    43,
+    44,
+    31
+   ]
+  },
+  {
+   "id": "language",
+   "label": "Language Understanding",
+   "raw": 0.6101,
+   "skill": 0.4585,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    11,
+    40,
+    41
+   ]
+  },
+  {
+   "id": "retrieval",
+   "label": "Retrieval & Classification",
+   "raw": 0.3015,
+   "skill": 0.2099,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 2,
+   "benchmarks": [
+    36,
+    37
+   ]
+  },
+  {
+   "id": "tools",
+   "label": "Tools & Automation",
+   "raw": 0.702,
+   "skill": 0.5754,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    1,
+    2,
+    6
+   ]
+  },
+  {
+   "id": "arts",
+   "label": "Arts & Human Judgment",
+   "raw": 0.5019,
+   "skill": 0.2566,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 5,
+   "benchmarks": [
+    20,
+    21,
+    22,
+    23,
+    50
+   ]
+  }
+ ],
+ "index_benchmarks": {
+  "1": {
+   "raw": 0.9032,
+   "skill": 0.8693,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2592,
+   "tracks": [],
+   "in_index": true
+  },
+  "2": {
+   "raw": 0.4122,
+   "skill": 0.3517,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0933,
+   "tracks": [],
+   "in_index": true
+  },
+  "6": {
+   "raw": 0.7905,
+   "skill": 0.5052,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5245,
+   "tracks": [
+    {
+     "track": "RouterBench-0shot",
+     "score": 0.7797,
+     "headline": false
+    },
+    {
+     "track": "RouterBench-5shot",
+     "score": 0.8014,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "7": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "11": {
+   "raw": 0.7612,
+   "skill": 0.6547,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3085,
+   "tracks": [],
+   "in_index": true
+  },
+  "13": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "15": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "16": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "17": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "19": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "20": {
+   "raw": 0.8467,
+   "skill": 0.6933,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "21": {
+   "raw": 0.6054,
+   "skill": 0.2108,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "22": {
+   "raw": 0.0338,
+   "skill": 0.0262,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0078,
+   "tracks": [],
+   "in_index": true
+  },
+  "23": {
+   "raw": 0.5808,
+   "skill": 0.1616,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "24": {
+   "raw": 0.7491,
+   "skill": 0.6655,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "25": {
+   "raw": 0.3724,
+   "skill": 0.1633,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "30": {
+   "raw": 0.5788,
+   "skill": 0.4872,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [
+    {
+     "track": "GSM8K-4choice",
+     "score": 0.5967,
+     "headline": false
+    },
+    {
+     "track": "GSM8K-10choice",
+     "score": 0.561,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "31": {
+   "raw": 0.1348,
+   "skill": 0.0577,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0819,
+   "tracks": [],
+   "in_index": true
+  },
+  "36": {
+   "raw": 0.172,
+   "skill": 0.1335,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0444,
+   "tracks": [],
+   "in_index": true
+  },
+  "37": {
+   "raw": 0.4309,
+   "skill": 0.2862,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2027,
+   "tracks": [],
+   "in_index": true
+  },
+  "40": {
+   "raw": 0.4523,
+   "skill": 0.2953,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2227,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.313,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.4523,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.645,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.915,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "41": {
+   "raw": 0.6169,
+   "skill": 0.4254,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3333,
+   "tracks": [],
+   "in_index": true
+  },
+  "43": {
+   "raw": 0.4719,
+   "skill": 0.1622,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3697,
+   "tracks": [],
+   "in_index": true
+  },
+  "44": {
+   "raw": 0.6368,
+   "skill": 0.2736,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "50": {
+   "raw": 0.4427,
+   "skill": 0.1912,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.311,
+   "tracks": [],
+   "in_index": true
+  }
+ },
+ "benchmarks": {
+  "1": {
+   "catalog_id": 1,
+   "dataset": "BFCL",
+   "requests": 1694,
+   "answered": 1694,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1694,
+   "metric": "case exact accuracy",
+   "score": 0.9032,
+   "reference_same_cases": null,
+   "median_ms": 94.5,
+   "in_index": true
+  },
+  "2": {
+   "catalog_id": 2,
+   "dataset": "ToolRet",
+   "requests": 7704,
+   "answered": 7704,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 7704,
+   "metric": "nDCG@10",
+   "score": 0.4122,
+   "reference_same_cases": null,
+   "median_ms": 807.3,
+   "in_index": true
+  },
+  "3": {
+   "catalog_id": 3,
+   "dataset": "API-Bank",
+   "requests": 508,
+   "answered": 508,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 508,
+   "metric": "accuracy",
+   "score": 0.748,
+   "reference_same_cases": null,
+   "median_ms": 425.6,
+   "in_index": false
+  },
+  "4": {
+   "catalog_id": 4,
+   "dataset": "BANKING77",
+   "requests": 3080,
+   "answered": 3080,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 3080,
+   "metric": "macro-F1",
+   "score": 0.7149,
+   "reference_same_cases": null,
+   "median_ms": 68.5,
+   "in_index": false
+  },
+  "5": {
+   "catalog_id": 5,
+   "dataset": "CLINC150+OOS",
+   "requests": 5500,
+   "answered": 5500,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5500,
+   "metric": "macro-F1",
+   "score": 0.7391,
+   "reference_same_cases": null,
+   "median_ms": 115.0,
+   "in_index": false
+  },
+  "6": {
+   "catalog_id": 6,
+   "dataset": "RouterBench",
+   "requests": 10000,
+   "answered": 10000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 10000,
+   "metric": "selected quality (quality objective)",
+   "score": 0.7905,
+   "reference_same_cases": null,
+   "median_ms": 262.7,
+   "tracks": {
+    "RouterBench-0shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.7797121726963822,
+     "scored_requests": 5003
+    },
+    "RouterBench-5shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.801360816489894,
+     "scored_requests": 4997
+    }
+   },
+   "in_index": true
+  },
+  "9": {
+   "catalog_id": 9,
+   "dataset": "Home appliance simulator",
+   "requests": 160,
+   "answered": 160,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 160,
+   "metric": "case exact accuracy",
+   "score": 0.1187,
+   "reference_same_cases": null,
+   "median_ms": 1148.5,
+   "in_index": false
+  },
+  "10": {
+   "catalog_id": 10,
+   "dataset": "SGD/SGD-X",
+   "requests": 2500,
+   "answered": 2500,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2500,
+   "metric": "macro-F1",
+   "score": 0.5004,
+   "reference_same_cases": null,
+   "median_ms": 71.5,
+   "in_index": false
+  },
+  "11": {
+   "catalog_id": 11,
+   "dataset": "ContractNLI",
+   "requests": 123,
+   "answered": 123,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 123,
+   "metric": "macro-F1",
+   "score": 0.7612,
+   "reference_same_cases": null,
+   "median_ms": 1993.0,
+   "in_index": true
+  },
+  "12": {
+   "catalog_id": 12,
+   "dataset": "ANLI",
+   "requests": 3200,
+   "answered": 3200,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 3200,
+   "metric": "macro-F1",
+   "score": 0.6012,
+   "reference_same_cases": null,
+   "median_ms": 13.0,
+   "in_index": false
+  },
+  "20": {
+   "catalog_id": 20,
+   "dataset": "BPoMP",
+   "requests": 5000,
+   "answered": 5000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5000,
+   "metric": "accuracy",
+   "score": 0.8456,
+   "reference_same_cases": null,
+   "median_ms": 12.5,
+   "in_index": true
+  },
+  "21": {
+   "catalog_id": 21,
+   "dataset": "Humicroedit",
+   "requests": 2628,
+   "answered": 2628,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2628,
+   "metric": "accuracy",
+   "score": 0.6054,
+   "reference_same_cases": null,
+   "median_ms": 8.0,
+   "in_index": true
+  },
+  "22": {
+   "catalog_id": 22,
+   "dataset": "POP909-CL",
+   "requests": 2000,
+   "answered": 2000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2000,
+   "metric": "accuracy",
+   "score": 0.036,
+   "reference_same_cases": null,
+   "median_ms": 571.6,
+   "in_index": true
+  },
+  "23": {
+   "catalog_id": 23,
+   "dataset": "cfcolor",
+   "requests": 5000,
+   "answered": 5000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5000,
+   "metric": "accuracy",
+   "score": 0.6016,
+   "reference_same_cases": null,
+   "median_ms": 33.4,
+   "in_index": true
+  },
+  "24": {
+   "catalog_id": 24,
+   "dataset": "MMLU",
+   "requests": 14033,
+   "answered": 14033,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 14033,
+   "metric": "accuracy",
+   "score": 0.7375,
+   "reference_same_cases": null,
+   "median_ms": 13.0,
+   "in_index": true
+  },
+  "25": {
+   "catalog_id": 25,
+   "dataset": "GPQA Diamond",
+   "requests": 196,
+   "answered": 196,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 196,
+   "metric": "accuracy",
+   "score": 0.3724,
+   "reference_same_cases": null,
+   "median_ms": 23.5,
+   "in_index": true
+  },
+  "26": {
+   "catalog_id": 26,
+   "dataset": "ARC-Easy",
+   "requests": 2376,
+   "answered": 2376,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2376,
+   "metric": "accuracy",
+   "score": 0.9769,
+   "reference_same_cases": null,
+   "median_ms": 12.3,
+   "in_index": false
+  },
+  "27": {
+   "catalog_id": 27,
+   "dataset": "ARC-Challenge",
+   "requests": 1172,
+   "answered": 1172,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1172,
+   "metric": "accuracy",
+   "score": 0.9275,
+   "reference_same_cases": null,
+   "median_ms": 12.1,
+   "in_index": false
+  },
+  "28": {
+   "catalog_id": 28,
+   "dataset": "WinoGrande",
+   "requests": 1267,
+   "answered": 1267,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1267,
+   "metric": "accuracy",
+   "score": 0.7032,
+   "reference_same_cases": null,
+   "median_ms": 8.4,
+   "in_index": false
+  },
+  "29": {
+   "catalog_id": 29,
+   "dataset": "HellaSwag",
+   "requests": 10042,
+   "answered": 10042,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 10042,
+   "metric": "accuracy",
+   "score": 0.8194,
+   "reference_same_cases": null,
+   "median_ms": 18.6,
+   "in_index": false
+  },
+  "30": {
+   "catalog_id": 30,
+   "dataset": "GSM8K",
+   "requests": 2638,
+   "answered": 2638,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2638,
+   "metric": "accuracy",
+   "score": 0.5788,
+   "reference_same_cases": null,
+   "median_ms": 16.4,
+   "tracks": {
+    "GSM8K-10choice": {
+     "metric": "accuracy",
+     "score": 0.5610310841546626,
+     "scored_requests": 1319
+    },
+    "GSM8K-4choice": {
+     "metric": "accuracy",
+     "score": 0.5966641394996209,
+     "scored_requests": 1319
+    }
+   },
+   "in_index": true
+  },
+  "31": {
+   "catalog_id": 31,
+   "dataset": "ChessBench",
+   "requests": 5000,
+   "answered": 5000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5000,
+   "metric": "accuracy",
+   "score": 0.1348,
+   "reference_same_cases": null,
+   "median_ms": 88.3,
+   "in_index": true
+  },
+  "32": {
+   "catalog_id": 32,
+   "dataset": "MuSR",
+   "requests": 752,
+   "answered": 752,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 752,
+   "metric": "accuracy",
+   "score": 0.5678,
+   "reference_same_cases": null,
+   "median_ms": 61.7,
+   "in_index": false
+  },
+  "33": {
+   "catalog_id": 33,
+   "dataset": "SATA-Bench",
+   "requests": 1650,
+   "answered": 1650,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1650,
+   "metric": "case exact accuracy",
+   "score": 0.2594,
+   "reference_same_cases": null,
+   "median_ms": 213.7,
+   "in_index": false
+  },
+  "34": {
+   "catalog_id": 34,
+   "dataset": "SimpleBench",
+   "requests": 10,
+   "answered": 10,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 10,
+   "metric": "accuracy",
+   "score": 0.1,
+   "reference_same_cases": null,
+   "median_ms": 14.3,
+   "in_index": false
+  },
+  "36": {
+   "catalog_id": 36,
+   "dataset": "BRIGHT",
+   "requests": 1297,
+   "answered": 1297,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1297,
+   "metric": "nDCG@10",
+   "score": 0.172,
+   "reference_same_cases": null,
+   "median_ms": 1014.7,
+   "in_index": true
+  },
+  "37": {
+   "catalog_id": 37,
+   "dataset": "Amazon ESCI",
+   "requests": 5000,
+   "answered": 5000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5000,
+   "metric": "macro-F1",
+   "score": 0.4309,
+   "reference_same_cases": null,
+   "median_ms": 26.6,
+   "in_index": true
+  },
+  "38": {
+   "catalog_id": 38,
+   "dataset": "ACOS",
+   "requests": 5479,
+   "answered": 5479,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5479,
+   "metric": "case exact accuracy",
+   "score": 0.015,
+   "reference_same_cases": null,
+   "median_ms": 669.4,
+   "in_index": false
+  },
+  "39": {
+   "catalog_id": 39,
+   "dataset": "FinEntity",
+   "requests": 979,
+   "answered": 979,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 979,
+   "metric": "macro-F1",
+   "score": 0.8603,
+   "reference_same_cases": null,
+   "median_ms": 24.9,
+   "in_index": false
+  },
+  "40": {
+   "catalog_id": 40,
+   "dataset": "iSarcasmEval",
+   "requests": 4600,
+   "answered": 4600,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4600,
+   "metric": "Sarcasm F1 \u00b7 track A, English",
+   "score": 0.4523,
+   "reference_same_cases": null,
+   "median_ms": 8.6,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.313,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.4523,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.645,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.915,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "41": {
+   "catalog_id": 41,
+   "dataset": "VAST",
+   "requests": 3006,
+   "answered": 3006,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 3006,
+   "metric": "macro-F1",
+   "score": 0.6169,
+   "reference_same_cases": null,
+   "median_ms": 14.9,
+   "in_index": true
+  },
+  "42": {
+   "catalog_id": 42,
+   "dataset": "NLI4CT",
+   "requests": 5500,
+   "answered": 5500,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5500,
+   "metric": "macro-F1",
+   "score": 0.7618,
+   "reference_same_cases": null,
+   "median_ms": 37.0,
+   "in_index": false
+  },
+  "43": {
+   "catalog_id": 43,
+   "dataset": "CRUXEval",
+   "requests": 570,
+   "answered": 570,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 570,
+   "metric": "accuracy",
+   "score": 0.4719,
+   "reference_same_cases": null,
+   "median_ms": 13.7,
+   "in_index": true
+  },
+  "44": {
+   "catalog_id": 44,
+   "dataset": "CLadder",
+   "requests": 5000,
+   "answered": 5000,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5000,
+   "metric": "accuracy",
+   "score": 0.6368,
+   "reference_same_cases": null,
+   "median_ms": 13.7,
+   "in_index": true
+  },
+  "45": {
+   "catalog_id": 45,
+   "dataset": "HLE",
+   "requests": 501,
+   "answered": 501,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 501,
+   "metric": "accuracy",
+   "score": 0.1297,
+   "reference_same_cases": null,
+   "median_ms": 22.6,
+   "in_index": false
+  },
+  "48": {
+   "catalog_id": 48,
+   "dataset": "ForecastBench",
+   "requests": 10139,
+   "answered": 10139,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 10139,
+   "metric": "Brier (lower is better)",
+   "score": 0.2172,
+   "reference_same_cases": null,
+   "median_ms": 49.3,
+   "in_index": false
+  },
+  "50": {
+   "catalog_id": 50,
+   "dataset": "Habermas Machine",
+   "requests": 1676,
+   "answered": 1676,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1676,
+   "metric": "accuracy",
+   "score": 0.4427,
+   "reference_same_cases": null,
+   "median_ms": 55.1,
+   "in_index": true
+  }
+ },
+ "frozen_panel": {
+  "scores": {
+   "balanced_raw": 40.49,
+   "balanced_skill": 26.81,
+   "breadth_skill": 23.02
+  },
+  "categories": [
+   {
+    "id": "knowledge",
+    "raw": 0.5618,
+    "skill": 0.3504,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "language",
+    "raw": 0.5125,
+    "skill": 0.3766,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "tools",
+    "raw": 0.4212,
+    "skill": 0.3453,
+    "coverage": 0.6,
+    "pending": 0.4
+   },
+   {
+    "id": "games",
+    "raw": 0.027,
+    "skill": 0.0115,
+    "coverage": 0.2,
+    "pending": 0.8
+   },
+   {
+    "id": "arts",
+    "raw": 0.5019,
+    "skill": 0.2566,
+    "coverage": 1.0,
+    "pending": 0.0
+   }
+  ],
+  "coverage": 0.76,
+  "pending": 0.24,
+  "note": "25-benchmark frozen panel with the six interactive benchmarks scored as zero (provisional lower bound); not the headline index."
+ },
+ "formulas": [
+  {
+   "id": "balanced_raw",
+   "normalization": "raw",
+   "formula": "100*sum_c(0.2*category[c])"
+  },
+  {
+   "id": "balanced_skill",
+   "normalization": "skill",
+   "formula": "100*sum_c(0.2*category[c])"
+  },
+  {
+   "id": "breadth_skill",
+   "normalization": "skill",
+   "shift": 0.1,
+   "formula": "100*(product_c((0.1+0.9*category[c])**0.2)-0.1)/0.9"
+  }
+ ],
+ "panel_id": "core25-observed-protocol-v1",
+ "edition": "Decision Index 0.1 (archived 19-benchmark edition)"
+}

eval/decision-index-0.1-minus-dis.json

@@ -0,0 +1,1070 @@
+{
+ "engine": "blink-4b",
+ "generated_utc": "2026-09-24T09:01:59+00:00",
+ "suite": {
+  "requests": 132422,
+  "scoreable": 131980,
+  "excluded": 442,
+  "benchmarks": 37,
+  "rows_sha256": "750d353a3a83af615c67cfe9752e005bf09e6c28d9c4ba28d3a9f57ba8536cfd"
+ },
+ "completed": 132422,
+ "complete": true,
+ "counts": {
+  "ok": 132422
+ },
+ "latency_ms": {
+  "median": 33.4,
+  "p95": 765.3,
+  "mean": 169.5
+ },
+ "decision_index": 52.29,
+ "scores": {
+  "balanced_raw": 52.29,
+  "balanced_skill": 36.28,
+  "breadth_skill": 34.4
+ },
+ "areas": [
+  {
+   "id": "knowledge",
+   "label": "Knowledge & Reasoning",
+   "raw": 0.4935,
+   "skill": 0.3056,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 6,
+   "benchmarks": [
+    24,
+    25,
+    30,
+    43,
+    44,
+    31
+   ]
+  },
+  {
+   "id": "language",
+   "label": "Language Understanding",
+   "raw": 0.6154,
+   "skill": 0.4657,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    11,
+    40,
+    41
+   ]
+  },
+  {
+   "id": "retrieval",
+   "label": "Retrieval & Classification",
+   "raw": 0.301,
+   "skill": 0.2094,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 2,
+   "benchmarks": [
+    36,
+    37
+   ]
+  },
+  {
+   "id": "tools",
+   "label": "Tools & Automation",
+   "raw": 0.702,
+   "skill": 0.5755,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    1,
+    2,
+    6
+   ]
+  },
+  {
+   "id": "arts",
+   "label": "Arts & Human Judgment",
+   "raw": 0.5026,
+   "skill": 0.2579,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 5,
+   "benchmarks": [
+    20,
+    21,
+    22,
+    23,
+    50
+   ]
+  }
+ ],
+ "index_benchmarks": {
+  "1": {
+   "raw": 0.9034,
+   "skill": 0.8696,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2594,
+   "tracks": [],
+   "in_index": true
+  },
+  "2": {
+   "raw": 0.4117,
+   "skill": 0.3512,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0933,
+   "tracks": [],
+   "in_index": true
+  },
+  "6": {
+   "raw": 0.7908,
+   "skill": 0.5057,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5248,
+   "tracks": [
+    {
+     "track": "RouterBench-0shot",
+     "score": 0.7801,
+     "headline": false
+    },
+    {
+     "track": "RouterBench-5shot",
+     "score": 0.8016,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "7": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "11": {
+   "raw": 0.773,
+   "skill": 0.6717,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3085,
+   "tracks": [],
+   "in_index": true
+  },
+  "13": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "15": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "16": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "17": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "19": {
+   "raw": 0.0,
+   "skill": 0.0,
+   "coverage": 0.0,
+   "pending": 1.0,
+   "random": null,
+   "tracks": [],
+   "in_index": false
+  },
+  "20": {
+   "raw": 0.8463,
+   "skill": 0.6927,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "21": {
+   "raw": 0.6068,
+   "skill": 0.2136,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "22": {
+   "raw": 0.0333,
+   "skill": 0.0258,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0078,
+   "tracks": [],
+   "in_index": true
+  },
+  "23": {
+   "raw": 0.5805,
+   "skill": 0.1611,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "24": {
+   "raw": 0.7487,
+   "skill": 0.665,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "25": {
+   "raw": 0.3798,
+   "skill": 0.1731,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "30": {
+   "raw": 0.5763,
+   "skill": 0.4843,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [
+    {
+     "track": "GSM8K-4choice",
+     "score": 0.5958,
+     "headline": false
+    },
+    {
+     "track": "GSM8K-10choice",
+     "score": 0.5567,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "31": {
+   "raw": 0.1352,
+   "skill": 0.0579,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0821,
+   "tracks": [],
+   "in_index": true
+  },
+  "36": {
+   "raw": 0.1721,
+   "skill": 0.134,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.044,
+   "tracks": [],
+   "in_index": true
+  },
+  "37": {
+   "raw": 0.4299,
+   "skill": 0.2849,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2027,
+   "tracks": [],
+   "in_index": true
+  },
+  "40": {
+   "raw": 0.4576,
+   "skill": 0.3022,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2227,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.3059,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.4576,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.6432,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.9146,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "41": {
+   "raw": 0.6155,
+   "skill": 0.4233,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3333,
+   "tracks": [],
+   "in_index": true
+  },
+  "43": {
+   "raw": 0.4851,
+   "skill": 0.1812,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3711,
+   "tracks": [],
+   "in_index": true
+  },
+  "44": {
+   "raw": 0.6361,
+   "skill": 0.2722,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "50": {
+   "raw": 0.4462,
+   "skill": 0.1962,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.311,
+   "tracks": [],
+   "in_index": true
+  }
+ },
+ "benchmarks": {
+  "1": {
+   "catalog_id": 1,
+   "dataset": "BFCL",
+   "requests": 1626,
+   "answered": 1626,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1626,
+   "metric": "case exact accuracy",
+   "score": 0.9034,
+   "reference_same_cases": null,
+   "median_ms": 93.6,
+   "in_index": true
+  },
+  "2": {
+   "catalog_id": 2,
+   "dataset": "ToolRet",
+   "requests": 7636,
+   "answered": 7636,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 7636,
+   "metric": "nDCG@10",
+   "score": 0.4117,
+   "reference_same_cases": null,
+   "median_ms": 807.5,
+   "in_index": true
+  },
+  "3": {
+   "catalog_id": 3,
+   "dataset": "API-Bank",
+   "requests": 440,
+   "answered": 440,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 440,
+   "metric": "accuracy",
+   "score": 0.7386,
+   "reference_same_cases": null,
+   "median_ms": 425.8,
+   "in_index": false
+  },
+  "4": {
+   "catalog_id": 4,
+   "dataset": "BANKING77",
+   "requests": 3012,
+   "answered": 3012,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 3012,
+   "metric": "macro-F1",
+   "score": 0.7127,
+   "reference_same_cases": null,
+   "median_ms": 68.5,
+   "in_index": false
+  },
+  "5": {
+   "catalog_id": 5,
+   "dataset": "CLINC150+OOS",
+   "requests": 5432,
+   "answered": 5432,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5432,
+   "metric": "macro-F1",
+   "score": 0.7388,
+   "reference_same_cases": null,
+   "median_ms": 115.0,
+   "in_index": false
+  },
+  "6": {
+   "catalog_id": 6,
+   "dataset": "RouterBench",
+   "requests": 9864,
+   "answered": 9864,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 9864,
+   "metric": "selected quality (quality objective)",
+   "score": 0.7908,
+   "reference_same_cases": null,
+   "median_ms": 262.7,
+   "tracks": {
+    "RouterBench-0shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.7800709219858156,
+     "scored_requests": 4935
+    },
+    "RouterBench-5shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.8016129032258065,
+     "scored_requests": 4929
+    }
+   },
+   "in_index": true
+  },
+  "9": {
+   "catalog_id": 9,
+   "dataset": "Home appliance simulator",
+   "requests": 93,
+   "answered": 93,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 93,
+   "metric": "case exact accuracy",
+   "score": 0.0968,
+   "reference_same_cases": null,
+   "median_ms": 1146.4,
+   "in_index": false
+  },
+  "10": {
+   "catalog_id": 10,
+   "dataset": "SGD/SGD-X",
+   "requests": 2433,
+   "answered": 2433,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2433,
+   "metric": "macro-F1",
+   "score": 0.4993,
+   "reference_same_cases": null,
+   "median_ms": 71.5,
+   "in_index": false
+  },
+  "11": {
+   "catalog_id": 11,
+   "dataset": "ContractNLI",
+   "requests": 56,
+   "answered": 56,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 56,
+   "metric": "macro-F1",
+   "score": 0.773,
+   "reference_same_cases": null,
+   "median_ms": 1998.1,
+   "in_index": true
+  },
+  "12": {
+   "catalog_id": 12,
+   "dataset": "ANLI",
+   "requests": 3133,
+   "answered": 3133,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 3133,
+   "metric": "macro-F1",
+   "score": 0.6021,
+   "reference_same_cases": null,
+   "median_ms": 13.0,
+   "in_index": false
+  },
+  "20": {
+   "catalog_id": 20,
+   "dataset": "BPoMP",
+   "requests": 4696,
+   "answered": 4696,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4696,
+   "metric": "accuracy",
+   "score": 0.8458,
+   "reference_same_cases": null,
+   "median_ms": 12.5,
+   "in_index": true
+  },
+  "21": {
+   "catalog_id": 21,
+   "dataset": "Humicroedit",
+   "requests": 2561,
+   "answered": 2561,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2561,
+   "metric": "accuracy",
+   "score": 0.6068,
+   "reference_same_cases": null,
+   "median_ms": 8.0,
+   "in_index": true
+  },
+  "22": {
+   "catalog_id": 22,
+   "dataset": "POP909-CL",
+   "requests": 1933,
+   "answered": 1933,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1933,
+   "metric": "accuracy",
+   "score": 0.0347,
+   "reference_same_cases": null,
+   "median_ms": 571.4,
+   "in_index": true
+  },
+  "23": {
+   "catalog_id": 23,
+   "dataset": "cfcolor",
+   "requests": 4933,
+   "answered": 4933,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4933,
+   "metric": "accuracy",
+   "score": 0.6019,
+   "reference_same_cases": null,
+   "median_ms": 33.4,
+   "in_index": true
+  },
+  "24": {
+   "catalog_id": 24,
+   "dataset": "MMLU",
+   "requests": 13966,
+   "answered": 13966,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 13966,
+   "metric": "accuracy",
+   "score": 0.7374,
+   "reference_same_cases": null,
+   "median_ms": 13.0,
+   "in_index": true
+  },
+  "25": {
+   "catalog_id": 25,
+   "dataset": "GPQA Diamond",
+   "requests": 129,
+   "answered": 129,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 129,
+   "metric": "accuracy",
+   "score": 0.3798,
+   "reference_same_cases": null,
+   "median_ms": 24.3,
+   "in_index": true
+  },
+  "26": {
+   "catalog_id": 26,
+   "dataset": "ARC-Easy",
+   "requests": 2309,
+   "answered": 2309,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2309,
+   "metric": "accuracy",
+   "score": 0.9766,
+   "reference_same_cases": null,
+   "median_ms": 12.3,
+   "in_index": false
+  },
+  "27": {
+   "catalog_id": 27,
+   "dataset": "ARC-Challenge",
+   "requests": 1105,
+   "answered": 1105,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1105,
+   "metric": "accuracy",
+   "score": 0.9276,
+   "reference_same_cases": null,
+   "median_ms": 12.1,
+   "in_index": false
+  },
+  "28": {
+   "catalog_id": 28,
+   "dataset": "WinoGrande",
+   "requests": 1200,
+   "answered": 1200,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1200,
+   "metric": "accuracy",
+   "score": 0.7008,
+   "reference_same_cases": null,
+   "median_ms": 8.4,
+   "in_index": false
+  },
+  "29": {
+   "catalog_id": 29,
+   "dataset": "HellaSwag",
+   "requests": 9975,
+   "answered": 9975,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 9975,
+   "metric": "accuracy",
+   "score": 0.8193,
+   "reference_same_cases": null,
+   "median_ms": 18.6,
+   "in_index": false
+  },
+  "30": {
+   "catalog_id": 30,
+   "dataset": "GSM8K",
+   "requests": 2504,
+   "answered": 2504,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2504,
+   "metric": "accuracy",
+   "score": 0.5763,
+   "reference_same_cases": null,
+   "median_ms": 16.4,
+   "tracks": {
+    "GSM8K-10choice": {
+     "metric": "accuracy",
+     "score": 0.5567092651757188,
+     "scored_requests": 1252
+    },
+    "GSM8K-4choice": {
+     "metric": "accuracy",
+     "score": 0.5958466453674122,
+     "scored_requests": 1252
+    }
+   },
+   "in_index": true
+  },
+  "31": {
+   "catalog_id": 31,
+   "dataset": "ChessBench",
+   "requests": 4933,
+   "answered": 4933,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4933,
+   "metric": "accuracy",
+   "score": 0.1352,
+   "reference_same_cases": null,
+   "median_ms": 88.3,
+   "in_index": true
+  },
+  "32": {
+   "catalog_id": 32,
+   "dataset": "MuSR",
+   "requests": 685,
+   "answered": 685,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 685,
+   "metric": "accuracy",
+   "score": 0.5577,
+   "reference_same_cases": null,
+   "median_ms": 61.4,
+   "in_index": false
+  },
+  "33": {
+   "catalog_id": 33,
+   "dataset": "SATA-Bench",
+   "requests": 1583,
+   "answered": 1583,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1583,
+   "metric": "case exact accuracy",
+   "score": 0.2577,
+   "reference_same_cases": null,
+   "median_ms": 211.0,
+   "in_index": false
+  },
+  "36": {
+   "catalog_id": 36,
+   "dataset": "BRIGHT",
+   "requests": 1230,
+   "answered": 1230,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1230,
+   "metric": "nDCG@10",
+   "score": 0.1721,
+   "reference_same_cases": null,
+   "median_ms": 1012.0,
+   "in_index": true
+  },
+  "37": {
+   "catalog_id": 37,
+   "dataset": "Amazon ESCI",
+   "requests": 4933,
+   "answered": 4933,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4933,
+   "metric": "macro-F1",
+   "score": 0.4299,
+   "reference_same_cases": null,
+   "median_ms": 26.6,
+   "in_index": true
+  },
+  "38": {
+   "catalog_id": 38,
+   "dataset": "ACOS",
+   "requests": 5212,
+   "answered": 5212,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5212,
+   "metric": "case exact accuracy",
+   "score": 0.0135,
+   "reference_same_cases": null,
+   "median_ms": 669.5,
+   "in_index": false
+  },
+  "39": {
+   "catalog_id": 39,
+   "dataset": "FinEntity",
+   "requests": 912,
+   "answered": 912,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 912,
+   "metric": "macro-F1",
+   "score": 0.8571,
+   "reference_same_cases": null,
+   "median_ms": 25.0,
+   "in_index": false
+  },
+  "40": {
+   "catalog_id": 40,
+   "dataset": "iSarcasmEval",
+   "requests": 4533,
+   "answered": 4533,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4533,
+   "metric": "Sarcasm F1 \u00b7 track A, English",
+   "score": 0.4576,
+   "reference_same_cases": null,
+   "median_ms": 8.5,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.3059,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.4576,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.6432,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.9146,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "41": {
+   "catalog_id": 41,
+   "dataset": "VAST",
+   "requests": 2939,
+   "answered": 2939,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 2939,
+   "metric": "macro-F1",
+   "score": 0.6155,
+   "reference_same_cases": null,
+   "median_ms": 14.9,
+   "in_index": true
+  },
+  "42": {
+   "catalog_id": 42,
+   "dataset": "NLI4CT",
+   "requests": 5433,
+   "answered": 5433,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 5433,
+   "metric": "macro-F1",
+   "score": 0.7615,
+   "reference_same_cases": null,
+   "median_ms": 37.0,
+   "in_index": false
+  },
+  "43": {
+   "catalog_id": 43,
+   "dataset": "CRUXEval",
+   "requests": 503,
+   "answered": 503,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 503,
+   "metric": "accuracy",
+   "score": 0.4851,
+   "reference_same_cases": null,
+   "median_ms": 13.7,
+   "in_index": true
+  },
+  "44": {
+   "catalog_id": 44,
+   "dataset": "CLadder",
+   "requests": 4933,
+   "answered": 4933,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 4933,
+   "metric": "accuracy",
+   "score": 0.6361,
+   "reference_same_cases": null,
+   "median_ms": 13.7,
+   "in_index": true
+  },
+  "45": {
+   "catalog_id": 45,
+   "dataset": "HLE",
+   "requests": 434,
+   "answered": 434,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 434,
+   "metric": "accuracy",
+   "score": 0.1313,
+   "reference_same_cases": null,
+   "median_ms": 22.7,
+   "in_index": false
+  },
+  "48": {
+   "catalog_id": 48,
+   "dataset": "ForecastBench",
+   "requests": 10072,
+   "answered": 10072,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 10072,
+   "metric": "Brier (lower is better)",
+   "score": 0.2171,
+   "reference_same_cases": null,
+   "median_ms": 49.3,
+   "in_index": false
+  },
+  "50": {
+   "catalog_id": 50,
+   "dataset": "Habermas Machine",
+   "requests": 1609,
+   "answered": 1609,
+   "unsupported": 0,
+   "errors": 0,
+   "abstained": 0,
+   "pending": 0,
+   "scored_requests": 1609,
+   "metric": "accuracy",
+   "score": 0.4462,
+   "reference_same_cases": null,
+   "median_ms": 55.0,
+   "in_index": true
+  }
+ },
+ "frozen_panel": {
+  "scores": {
+   "balanced_raw": 40.61,
+   "balanced_skill": 26.98,
+   "breadth_skill": 23.15
+  },
+  "categories": [
+   {
+    "id": "knowledge",
+    "raw": 0.5652,
+    "skill": 0.3552,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "language",
+    "raw": 0.5142,
+    "skill": 0.379,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "tools",
+    "raw": 0.4212,
+    "skill": 0.3453,
+    "coverage": 0.6,
+    "pending": 0.4
+   },
+   {
+    "id": "games",
+    "raw": 0.027,
+    "skill": 0.0116,
+    "coverage": 0.2,
+    "pending": 0.8
+   },
+   {
+    "id": "arts",
+    "raw": 0.5026,
+    "skill": 0.2579,
+    "coverage": 1.0,
+    "pending": 0.0
+   }
+  ],
+  "coverage": 0.76,
+  "pending": 0.24,
+  "note": "25-benchmark frozen panel with the six interactive benchmarks scored as zero (provisional lower bound); not the headline index."
+ },
+ "formulas": [
+  {
+   "id": "balanced_raw",
+   "normalization": "raw",
+   "formula": "100*sum_c(0.2*category[c])"
+  },
+  {
+   "id": "balanced_skill",
+   "normalization": "skill",
+   "formula": "100*sum_c(0.2*category[c])"
+  },
+  {
+   "id": "breadth_skill",
+   "normalization": "skill",
+   "shift": 0.1,
+   "formula": "100*(product_c((0.1+0.9*category[c])**0.2)-0.1)/0.9"
+  }
+ ],
+ "panel_id": "core25-observed-protocol-v1",
+ "edition": "Decision Index 0.1 (archived 19-benchmark edition)",
+ "subset": {
+  "name": "0.1 suite minus the 3,000-request DI-S selection sample",
+  "requests": 129422,
+  "ids_sha256": "b738768b0cd2076ead8c637cddd2d1b233094f46524153da16444ff7a98f6aab",
+  "note": "The 'suite' block above describes the parent 0.1 suite; scores cover the subset only."
+ }
+}

eval/jevbench-public-proxy.json

@@ -0,0 +1,29 @@
+{
+ "tiers": {
+  "easy": 1.0,
+  "standard": 0.9861111111111112,
+  "hard": 0.7207207207207207
+ },
+ "hard_ece": 0.0672866582962707,
+ "prob_tvd": 0.2258727428861121,
+ "calibration": 81.97769702606733,
+ "intelligence_public": 81.67291558166173,
+ "input_tokens_per_decision": 698.922077922078,
+ "temperature": 1.0,
+ "hard_by_family": {
+  "adversarial": 1.0,
+  "ambiguous": 0.857,
+  "judge_hard": 0.647,
+  "long_policy": 0.579,
+  "multi_hop": 0.833,
+  "probability": 0.7,
+  "routing_hard": 1.0,
+  "temporal_numeric": 0.4,
+  "tradeoff": 0.833,
+  "trap": 1.0
+ },
+ "p50_s": 0.06382748000032734,
+ "p95_s": 0.17542972600494977,
+ "speed": 88.5677868991755,
+ "note": "JevBench v1.2 public items (231) scored with JevBench's own code; a development proxy, not an official JevBench result."
+}

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": 248044,
+  "transformers_version": "5.17.0",
+  "use_cache": true
+}

model-00001-of-00002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a3dbd1ed71004fd0e0b5ec4912f387e7cad0e1118ef12d41921911fc55d96fb
+size 4972947968

model-00002-of-00002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8b6d35df130ce90b1feec8c4fb66906ea5d2843e7f8d0a39fd41abc82c38374
+size 3438610328

model.safetensors.index.json

@@ -0,0 +1,434 @@
+{
+  "metadata": {
+    "total_parameters": 4205751296,
+    "total_size": 8411502592
+  },
+  "weight_map": {
+    "model.language_model.embed_tokens.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.0.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.1.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.10.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.11.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.12.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.13.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.14.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.15.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.16.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.16.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.16.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.17.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.18.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.19.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.2.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.2.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.20.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.20.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.21.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.22.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.23.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.24.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.25.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.26.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.27.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.28.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.29.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.3.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.3.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.30.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.A_log": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.conv1d.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.dt_bias": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_a.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_b.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_qkv.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_z.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.linear_attn.out_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.30.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.input_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.mlp.down_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.mlp.gate_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.mlp.up_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.post_attention_layernorm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.self_attn.k_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.self_attn.k_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.self_attn.o_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.self_attn.q_norm.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.self_attn.q_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.31.self_attn.v_proj.weight": "model-00002-of-00002.safetensors",
+    "model.language_model.layers.4.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.4.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.5.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.6.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.self_attn.k_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.self_attn.k_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.self_attn.o_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.self_attn.q_norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.self_attn.q_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.7.self_attn.v_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.8.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.input_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.A_log": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.conv1d.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.dt_bias": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_a.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_b.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_qkv.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_z.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.norm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.linear_attn.out_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.mlp.down_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.mlp.gate_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.mlp.up_proj.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.layers.9.post_attention_layernorm.weight": "model-00001-of-00002.safetensors",
+    "model.language_model.norm.weight": "model-00002-of-00002.safetensors"
+  }
+}

serve.py

@@ -0,0 +1,167 @@
+"""blink server: a Jev-compatible decision endpoint.
+
+    pip install "torch==2.13.0" "transformers==5.17.0" "flash-linear-attention==0.5.2" accelerate safetensors huggingface_hub
+    hf download thegovind/blink-4b --revision v1.0 --local-dir blink-4b
+    python blink-4b/serve.py --model ./blink-4b --port 8000
+
+POST /v1/systemone  {"state": ..., "questions": {...}}  ->  {"model", "answers", "usage"}
+GET  /healthz       ->  {"ok", "model", "revision", "weights_verified", "hub_offline", "warmup", "kernels", "versions"}
+
+Requests are served one at a time. A request over a limit (options per choice, context length,
+questions per request) gets HTTP 422 with the reason; nothing is truncated. With weights.sha256 beside
+the weights, every listed file is hashed before serving (weights_verified). Serving a local folder switches
+the Hugging Face libraries to offline mode before any of them loads (hub_offline reports the setting the
+libraries actually use); the server does not otherwise restrict the network.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import socket
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+WARMUP = ("Order 4471 arrived with a cracked screen. The customer attached photos and wants a replacement.",
+          {"route": {"type": "choice", "instructions": "Which team should handle this?",
+                     "criteria": {"returns": "Damaged or wrong items", "billing": "Charges and refunds",
+                                  "shipping": "Late or lost parcels"}},
+           "urgent": {"type": "noul", "instructions": "Does this need a reply today?"}})
+
+
+def sha256(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 24), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def verify(root: str):
+    """True/False against weights.sha256 ("<sha256>  <file>" lines) beside the weights; None without one."""
+    manifest = os.path.join(root, "weights.sha256")
+    if not os.path.exists(manifest):
+        return None, []
+    bad = []
+    with open(manifest, encoding="utf-8") as fh:
+        for line in fh:
+            if line.strip():
+                digest, name = line.split(None, 1)
+                name = name.strip()
+                path = os.path.join(root, name)
+                if not os.path.exists(path) or sha256(path) != digest:
+                    bad.append(name)
+    return not bad, bad
+
+
+def versions() -> dict:
+    out = {}
+    for mod in ("torch", "transformers", "fla"):
+        try:
+            out[mod] = __import__(mod).__version__
+        except Exception:
+            out[mod] = None
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Serve blink over a Jev-compatible HTTP API.")
+    ap.add_argument("--model", default=os.environ.get("BLINK_MODEL", "thegovind/blink-4b"))
+    ap.add_argument("--revision", default=os.environ.get("BLINK_REVISION"))
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--port", type=int, default=8000)
+    a = ap.parse_args()
+
+    local = os.path.isdir(a.model)
+    if local:
+        # the Hub libraries read these once, when they are first imported, so they must be set before that
+        for var in ("HF_HUB_OFFLINE", "TRANSFORMERS_OFFLINE", "HF_HUB_DISABLE_TELEMETRY"):
+            os.environ.setdefault(var, "1")
+    os.environ["BLINK_ENGINE"] = "torch"
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    import blink
+
+    if local:
+        root = a.model
+    else:
+        from huggingface_hub import snapshot_download
+
+        root = snapshot_download(a.model, revision=a.revision)
+    verified, bad = verify(root)
+    if verified is False:
+        sys.exit(f"weights.sha256 mismatch: {', '.join(bad)}")
+    engine = blink.TorchEngine(root, None, blink.TEMPERATURE)
+    blink._ENGINE = engine
+    first = blink.decide(*WARMUP)["answers"]
+    repeat_identical = blink.decide(*WARMUP)["answers"] == first
+    ver = versions()
+    kernels = f"flash-linear-attention {ver['fla']}" if ver["fla"] else "reference (much slower; install flash-linear-attention)"
+    try:
+        from huggingface_hub import constants as hub_constants
+
+        hub_offline = bool(hub_constants.HF_HUB_OFFLINE)
+    except Exception:
+        hub_offline = None
+    health = {"ok": True, "model": a.model, "revision": a.revision, "weights_verified": verified,
+              "hub_offline": hub_offline, "warmup": {"repeat_identical": repeat_identical}, "kernels": kernels,
+              "versions": ver}
+    lock = threading.Lock()
+
+    class Handler(BaseHTTPRequestHandler):
+        protocol_version = "HTTP/1.1"
+
+        def log_message(self, fmt, *args):  # quiet by default
+            pass
+
+        def setup(self):
+            super().setup()
+            # a response is two writes (headers, then body); without TCP_NODELAY the body waits
+            # on the client's delayed ACK, a flat ~40 ms on every request of a kept-alive connection
+            self.connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+
+        def _send(self, code: int, obj: dict) -> None:
+            body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
+            self.send_response(code)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self):
+            if self.path.rstrip("/") in ("/healthz", "/health"):
+                return self._send(200, health)
+            return self._send(404, {"error": "not found"})
+
+        def do_POST(self):
+            if self.path.rstrip("/") != "/v1/systemone":
+                return self._send(404, {"error": "not found"})
+            try:
+                size = int(self.headers.get("Content-Length") or 0)
+                req = json.loads(self.rfile.read(size) or b"{}")
+            except (ValueError, json.JSONDecodeError) as exc:
+                return self._send(400, {"error": f"invalid JSON: {exc}"})
+            if not isinstance(req, dict):
+                return self._send(400, {"error": "the body must be a JSON object"})
+            try:
+                with lock:
+                    out = blink.decide(req.get("state"), req.get("questions"))
+            except blink.BlinkError as exc:
+                return self._send(422, {"error": str(exc)})
+            except Exception as exc:  # noqa: BLE001 - report, keep serving
+                return self._send(500, {"error": f"{type(exc).__name__}: {exc}"})
+            return self._send(200, {
+                "model": a.model,
+                "answers": out["answers"],
+                "usage": {"input_tokens": out["meta"]["input_tokens"], "output_tokens": 0},
+            })
+
+    server = ThreadingHTTPServer((a.host, a.port), Handler)
+    print(f"blink serving {a.model} on http://{a.host}:{a.port} ({kernels}; weights_verified={verified})", flush=True)
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523
+size 19989325

tokenizer_config.json

@@ -0,0 +1,32 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

weights.sha256

@@ -0,0 +1,8 @@
+a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715  chat_template.jinja
+63f47812d0f11118e4d252d2b3ad488707eb9287a11589f4fd382a1d31182724  config.json
+62153eb6c69f2e1f426beaa8002b7186437e949c7588167085df14e10e9c0a73  generation_config.json
+1a3dbd1ed71004fd0e0b5ec4912f387e7cad0e1118ef12d41921911fc55d96fb  model-00001-of-00002.safetensors
+b8b6d35df130ce90b1feec8c4fb66906ea5d2843e7f8d0a39fd41abc82c38374  model-00002-of-00002.safetensors
+83620b40d724f8b286580b5c7c504222b0bdbdd7dc9f068e565132409c7eec9d  model.safetensors.index.json
+06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523  tokenizer.json
+66e427c470fe580fe8c7b5725d857af23d8417e37fae62667ec698306a19987b  tokenizer_config.json