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-MiMo.md

@@ -0,0 +1,23 @@
+# XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B
+
+blink-mimo-9b is fine-tuned from [XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B)
+(revision `2367e865d009c13ac81713a2878291d33ab28177`). Its model card declares `license: mit` and names
+[Qwen/Qwen3.5-9B](https://huggingface.co/Qwen/Qwen3.5-9B) as its base model (Apache-2.0; see `LICENSE-Qwen`). The upstream
+repository ships no separate licence file or copyright line; the MIT terms it declares are reproduced below.
+
+---
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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-9B (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) 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,293 @@
+---
+license: other
+license_name: blink-research
+license_link: LICENSE.md
+base_model: XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B
+library_name: transformers
+pipeline_tag: image-text-to-text
+inference: false
+tags:
+  - decision-model
+  - typed-decisions
+  - one-pass
+  - option-probabilities
+language:
+  - en
+---
+
+# blink-mimo-9b
+
+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
+
+### Decision Index 0.1 (archived edition)
+
+**Full suite: blink-mimo-9b 56.53 vs Jev 1.13.0 59.51.**
+
+**Training overlap:** Public train splits included ContractNLI, iSarcasmEval and VAST (the whole Language area), plus Amazon ESCI and Humicroedit. With Language set to Jev's score, this model's index would be 54.96 vs Jev's 59.51. That's arithmetic, not an ablation or a like-for-like comparison with models trained only on synthetic data.
+
+| Model | Size class | Decision Index 0.1 | Skill | Breadth |
+|---|---|---:|---:|---:|
+| **blink-mimo-9b** (this model) | 9B | 56.53 | 42.17 | 40.37 |
+| 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.
+
+Third in our local archived 0.1 comparison, behind blink-27b and Jev and ahead of every open entry in the September 22 snapshot (best: Jevfire).
+
+| Area | blink-mimo-9b | Jev 1.13.0 |
+|---|---:|---:|
+| Knowledge & Reasoning | 55.1 | 68.8 |
+| Language Understanding | 70.1 | 62.3 |
+| Retrieval & Classification | 34.8 | 37.0 |
+| Tools & Automation | 70.5 | 73.6 |
+| Arts & Human Judgment | 52.1 | 56.2 |
+
+<details><summary>Per benchmark (19 panel benchmarks, 0.1)</summary>
+
+| Area | Benchmark | This model | Jev 1.13.0 |
+|---|---|---:|---:|
+| Knowledge | MMLU | 0.802 | 0.917 |
+| Knowledge | GPQA Diamond | 0.408 | 0.783 |
+| Knowledge | GSM8K | 0.658 | 0.799 |
+| Knowledge | CRUXEval | 0.547 | 0.730 |
+| Knowledge | CLadder | 0.661 | 0.726 |
+| Knowledge | ChessBench | 0.229 | 0.172 |
+| Language | ContractNLI | 0.817 | 0.717 |
+| Language | iSarcasmEval | 0.506 | 0.505 |
+| Language | VAST | 0.780 | 0.646 |
+| Retrieval | BRIGHT | 0.177 | 0.187 |
+| Retrieval | Amazon ESCI | 0.520 | 0.552 |
+| Tools | BFCL | 0.893 | 0.958 |
+| Tools | ToolRet | 0.422 | 0.450 |
+| Tools | RouterBench | 0.799 | 0.799 |
+| Arts | BPoMP | 0.841 | 0.906 |
+| Arts | Humicroedit | 0.638 | 0.619 |
+| Arts | POP909-CL | 0.076 | 0.181 |
+| Arts | cfcolor | 0.597 | 0.647 |
+| Arts | Habermas Machine | 0.455 | 0.459 |
+
+</details>
+
+### JevBench: public items only
+
+| Model | Easy | Standard | Hard | Hard ECE | Official score |
+|---|---:|---:|---:|---:|---|
+| **blink-mimo-9b** | 48/48 | 70/72 | 77/111 (0.694) | 0.136 | not submitted |
+
+Same public-item harness as the other models. These are development results, not official scores or predictions; no official rank or parity is claimed. blink-4b is the JevBench entry. MiMo's hard ECE is 0.136 vs blink-4b's 0.067; it's less calibrated here. Its weakest public hard cases are date/number reasoning, trade-offs and long policies.
+
+### Picking the next click (our probe)
+
+| Input | blink-mimo-9b | MiMo base | blink-4b |
+|---|---:|---:|---:|
+| Page text | 53.8% | 49.0% | 55.4% |
+| Screenshot | 48.4% | 43.0% | — |
+
+Our harness and sampling on 500 Multimodal-Mind2Web test steps with five offered elements (chance 20%), not the official evaluation. Five choices are easier than ranking a whole page; blink never trained on web actions. Training lifted MiMo by about five points in both modes, but text still beats screenshots; blink-4b is as good with page text.
+
+## What we changed in the network
+
+| | What ships |
+|---|---|
+| Backbone | MiMo-V2.6-Distill-Qwen-9B (upstream revision 2367e86), a Qwen3.5-9B fine-tune; 32 decoder layers (24 Gated DeltaNet, 8 full-attention), hidden 4096, untied embeddings |
+| Vision | 27 encoder blocks, hidden 1152 projected to 4096; all 333 vision tensors unchanged |
+| Tuned | 43.3M LoRA parameters; all 248 targeted tensors changed, all 179 other language-model tensors bit-identical to MiMo |
+| Final weights | Merged and grafted into MiMo; vision-language reload with no missing or unexpected keys |
+| Serving | 9.41B parameters in the full checkpoint (0.46B vision); 8.95B text parameters serving decisions (17.9 GB in bf16); 18.8 GB total |
+
+**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.
+
+MiMo's vision tower stays byte-for-byte unchanged. The full checkpoint loads with MiMo's processor and transformers' image-text-to-text classes; `blink.py` and `serve.py` use its text side only. Screenshot results above come from our separate probe harness, not `blink.py`.
+
+**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. 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
+
+One pre-registered run, one epoch; no other MiMo variant was trained or picked. The gate was DI-S ≥ 55 before training: pass it, then read the full suite and release. DI-S intervals are a few points wide, so this is a narrow gate pass, not a claim of superiority.
+
+| Step | DI-S | Full 0.1 | Outside DI-S | Why |
+|---|---:|---:|---:|---|
+| MiMo base, zero-shot | 47.09 | — | — | Baseline before decision training. |
+| **blink-mimo-9b** (123,195 question rows; lr 5e-5; 615 steps) | 55.3 | 56.53 | 56.60 | Program-labelled reasoning, teacher questions and judge data cleared the gate; shipped. |
+
+DI-S areas: Knowledge 55.6, Language 66.4, Retrieval 33.0, Tools 70.7, Arts 50.8.
+
+## 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-mimo-9b"
+os.environ["BLINK_REVISION"] = "v1.0"
+sys.path.insert(0, os.path.dirname(hf_hub_download("thegovind/blink-mimo-9b", "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-mimo-9b --revision v1.0 --local-dir blink-mimo-9b
+python blink-mimo-9b/serve.py --model ./blink-mimo-9b --port 8000
+```
+
+In another terminal: `curl -s http://127.0.0.1:8000/healthz`.
+
+**Or use Docker** from the downloaded folder:
+
+```sh
+cd blink-mimo-9b
+docker build -t blink-mimo-9b . && docker run --rm --gpus all -p 127.0.0.1:8000:8000 blink-mimo-9b
+```
+
+<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-mimo-9b weights are 18.8 GB in bf16. Long prompts need more memory.
+
+</details>
+
+<details><summary>Model and probability readout</summary>
+
+| | |
+|---|---|
+| Base | [XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B](https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B) (MIT declared in the model card; see LICENSE-MiMo.md), full vision-language weights |
+| Adaptation | LoRA r16 / alpha 32 across the language model's attention, Gated DeltaNet and MLP; merged into the full MiMo checkpoint |
+| 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) |
+| 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 |
+|---|---:|---|
+| MiMo | 123,195 | 61,394 public-source · 23,894 program-generated reasoning · 12,000 decision worlds · 7,860 teacher-written question rows · 7,000 judge-style · 6,000 chess move choices · 5,047 exact-probability worlds |
+
+One pre-registered supervised run, one epoch (lr 5e-5, 615 steps). The mix joins the 27B's stage-1 public and exact-probability rows with its stage-2 reasoning, chess and decision worlds, plus judge-style data. Qwen3.8-27B wrote the teacher documents and typed questions. Public train splits include ContractNLI, iSarcasmEval, VAST, Amazon ESCI, Humicroedit, ANLI, WANLI, BoolQ, BANKING77, MedMCQA, AQuA, MMLU auxiliary train, SciQ and SuperGPQA.
+
+### Data sources and licences
+
+| Source | Licence |
+|---|---|
+| MMLU auxiliary train, CommonsenseQA, GSM8K | MIT |
+| AQuA-RAT, Amazon ESCI | Apache-2.0 |
+| searchless_chess | data CC BY 4.0 (Lichess-derived portions CC0); code Apache-2.0 |
+| MedMCQA | Apache-2.0 (dataset card) |
+| SuperGPQA | ODC-BY |
+| WANLI, ContractNLI, BANKING77 | 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 lab scorer agree within 1e-7 on this checkpoint (p99 |Δp| 1.4e-8); the published graft matches the evaluated adapter on JevBench's 231 public items (0 argmax changes, max |Δp| 0.0). The kit's per-request timer on 1,000 random suite requests served one at a time measured 68.3 ms median via HTTP vs 66.9 ms in-process. From a fresh Hub download and install at the pinned revision, `serve.py` with JevBench's stock adapter returned easy 48/48, standard 70/72 and hard 77/111, matching the evaluation's answers (0 argmax changes; max |Δp| about 0.03).
+- **Selection.** The prompt format came from earlier DI-S reads; this MiMo run used the sample as a pre-registered gate. The full suite followed that gate; it scored 56.60 on the 129,422 requests outside DI-S, which were not used for selection.
+- **Training overlap.** Public train splits also used by the 0.1 index: ContractNLI, iSarcasmEval, VAST, Amazon ESCI, Humicroedit, ChessBench (searchless_chess training positions; none of the 5,000 test positions), 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.
+- **Final-mixture audit.** Rechecked every question row (including teacher-written rows) 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.** 16 BANKING77/VAST training rows share a 13-word passage with 31 suite requests: 23 of VAST's 3,006 and 8 of BANKING77's 3,080. Two VAST training posts are near-duplicates of a test post; none of these texts is identical. Dropping those requests leaves the index at 56.53 (VAST 0.7805 → 0.7803); BANKING77 is outside the index.
+- **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.
+- **No MMLU-Pro or GPQA.** No rows from either were used in this fine-tune; SuperGPQA is a separate source.
+
+### Limits
+
+- English-centric. Training included Arabic iSarcasmEval rows; on the 0.1 suite, Arabic task A scored 0.321 and task C pairs 0.79. Broader multilingual performance hasn't been established.
+- Doesn't chat or explain answers.
+- Text in the state can sway the answer.
+- Its weakest public hard cases are date/number reasoning, trade-offs and long policies.
+
+</details>
+
+## Licence
+
+The MiMo model card declares MIT without a separate upstream licence file or copyright line (`LICENSE-MiMo.md`); its Qwen/Qwen3.5-9B base 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>
+
+Xiaomi MiMo (MiMo base) and the Qwen team (Qwen base). SemIf (MIT) for the evidence/criterion/options prompt layout. The Decision Index kit (MIT) and JevBench (MIT) for evaluation.
+
+</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,97 @@
+{%- macro render_value(value) -%}
+    {%- if value is string -%}
+        {{- value -}}
+    {%- else -%}
+        {{- value | tojson(ensure_ascii=False) -}}
+    {%- endif -%}
+{%- endmacro -%}
+
+{%- macro render_content(message_content) -%}
+    {%- if message_content is string -%}
+        {{- message_content -}}
+    {%- elif message_content is iterable -%}
+        {%- for part in message_content -%}
+            {%- if part is not mapping -%}
+                {{- part -}}
+            {%- elif part['type'] == 'image' or 'image' in part or 'image_url' in part -%}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' -}}
+            {%- elif part['type'] == 'audio' or part['type'] == 'input_audio' or 'audio' in part or 'audio_url' in part or 'input_audio' in part -%}
+                {{- '<|mimo_audio_start|><|audio_pad|><|mimo_audio_end|>' -}}
+            {%- elif part['type'] == 'video' or 'video' in part or 'video_url' in part -%}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' -}}
+            {%- elif 'text' in part -%}
+                {{- part['text'] -}}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- endif -%}
+{%- endmacro -%}
+
+{%- macro render_tools(tools) -%}
+    {{- 'You are provided with the following tools:\n\n<tools>' -}}
+    {%- for tool in tools -%}
+        {{- '\n' ~ (tool | tojson(ensure_ascii=False)) -}}
+    {%- endfor -%}
+    {{- '\n</tools>' -}}
+{%- endmacro -%}
+
+{%- macro render_tool_calls(tool_calls) -%}
+    {%- for tool_call in tool_calls -%}
+        {%- if tool_call.function is defined -%}
+            {%- set tool_call = tool_call.function -%}
+        {%- elif tool_call.custom is defined -%}
+            {%- set tool_call = tool_call.custom -%}
+        {%- endif -%}
+        {{- '<tool_call><function=' ~ tool_call.name ~ '>' -}}
+        {%- if tool_call.input is defined and tool_call.input is string -%}
+            {{- tool_call.input -}}
+        {%- elif tool_call.arguments -%}
+            {%- if tool_call.arguments is string -%}
+                {{- tool_call.arguments -}}
+            {%- else -%}
+                {%- for args_name, args_value in tool_call.arguments | items -%}
+                    {{- '<parameter=' ~ args_name ~ '>' ~ render_value(args_value) ~ '</parameter>' -}}
+                {%- endfor -%}
+            {%- endif -%}
+        {%- endif -%}
+        {{- '</function></tool_call>' -}}
+    {%- endfor -%}
+{%- endmacro -%}
+
+{%- macro render_assistant_message(message) -%}
+    {%- generation -%}
+    {%- set content = render_content(message.content) -%}
+    {%- set reasoning = message.reasoning_content if message.reasoning_content is string else '' -%}
+    {{- '<|im_start|>assistant\n<think>' ~ reasoning ~ '</think>' ~ content -}}
+    {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 -%}
+        {{- render_tool_calls(message.tool_calls) -}}
+    {%- endif -%}
+    {{- '<|im_end|>' -}}
+    {%- endgeneration -%}
+{%- endmacro -%}
+
+{%- if tools is defined and tools is iterable and tools | length > 0 -%}
+    {{- '<|im_start|>system\n' ~ render_tools(tools) ~ '<|im_end|>' -}}
+{%- endif -%}
+
+{%- for message in messages -%}
+    {%- if message.role == 'assistant' -%}
+        {{- render_assistant_message(message) -}}
+    {%- else -%}
+        {%- set body = render_content(message.content) -%}
+        {{- '<|im_start|>' ~ message.role ~ '\n' ~ body -}}
+        {%- if message.tools is defined and message.tools is iterable and message.tools | length > 0 -%}
+            {%- if body -%}
+                {{- '\n\n' -}}
+            {%- endif -%}
+            {{- render_tools(message.tools) -}}
+        {%- endif -%}
+        {{- '<|im_end|>' -}}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if add_generation_prompt -%}
+    {{- '<|im_start|>assistant\n' -}}
+    {%- if enable_thinking is false -%}
+        {{- '<think></think>' -}}
+    {%- endif -%}
+{%- endif -%}

config.json

@@ -0,0 +1,107 @@
+{
+  "architectures": [
+    "Qwen3_5ForConditionalGeneration"
+  ],
+  "image_token_id": 248056,
+  "model_type": "qwen3_5",
+  "text_config": {
+    "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": 4096,
+    "initializer_range": 0.02,
+    "intermediate_size": 12288,
+    "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": false,
+    "use_cache": true,
+    "vocab_size": 248320
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "5.12.1",
+  "video_token_id": 248057,
+  "vision_config": {
+    "deepstack_visual_indexes": [],
+    "depth": 27,
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 4304,
+    "model_type": "qwen3_5_vision",
+    "num_heads": 16,
+    "num_position_embeddings": 2304,
+    "out_hidden_size": 4096,
+    "patch_size": 16,
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  },
+  "vision_end_token_id": 248054,
+  "vision_start_token_id": 248053
+}

eval/decision-index-0.1-full.json

@@ -0,0 +1,1080 @@
+{
+ "engine": "blink-mimo-9b",
+ "generated_utc": "2026-09-24T14:47:48+00:00",
+ "suite": {
+  "requests": 132422,
+  "scoreable": 131980,
+  "excluded": 442,
+  "benchmarks": 37,
+  "rows_sha256": "750d353a3a83af615c67cfe9752e005bf09e6c28d9c4ba28d3a9f57ba8536cfd"
+ },
+ "completed": 132422,
+ "complete": true,
+ "counts": {
+  "ok": 132422
+ },
+ "latency_ms": {
+  "median": 49.9,
+  "p95": 1129.5,
+  "mean": 251.2
+ },
+ "decision_index": 56.53,
+ "scores": {
+  "balanced_raw": 56.53,
+  "balanced_skill": 42.17,
+  "breadth_skill": 40.37
+ },
+ "areas": [
+  {
+   "id": "knowledge",
+   "label": "Knowledge & Reasoning",
+   "raw": 0.5511,
+   "skill": 0.3834,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 6,
+   "benchmarks": [
+    24,
+    25,
+    30,
+    43,
+    44,
+    31
+   ]
+  },
+  {
+   "id": "language",
+   "label": "Language Understanding",
+   "raw": 0.7011,
+   "skill": 0.5901,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    11,
+    40,
+    41
+   ]
+  },
+  {
+   "id": "retrieval",
+   "label": "Retrieval & Classification",
+   "raw": 0.3484,
+   "skill": 0.2683,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 2,
+   "benchmarks": [
+    36,
+    37
+   ]
+  },
+  {
+   "id": "tools",
+   "label": "Tools & Automation",
+   "raw": 0.7045,
+   "skill": 0.5811,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    1,
+    2,
+    6
+   ]
+  },
+  {
+   "id": "arts",
+   "label": "Arts & Human Judgment",
+   "raw": 0.5214,
+   "skill": 0.2859,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 5,
+   "benchmarks": [
+    20,
+    21,
+    22,
+    23,
+    50
+   ]
+  }
+ ],
+ "index_benchmarks": {
+  "1": {
+   "raw": 0.8926,
+   "skill": 0.855,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2592,
+   "tracks": [],
+   "in_index": true
+  },
+  "2": {
+   "raw": 0.4222,
+   "skill": 0.3627,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0933,
+   "tracks": [],
+   "in_index": true
+  },
+  "6": {
+   "raw": 0.7989,
+   "skill": 0.5256,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5245,
+   "tracks": [
+    {
+     "track": "RouterBench-0shot",
+     "score": 0.7864,
+     "headline": false
+    },
+    {
+     "track": "RouterBench-5shot",
+     "score": 0.8114,
+     "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.8171,
+   "skill": 0.7355,
+   "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.8408,
+   "skill": 0.6817,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "21": {
+   "raw": 0.6381,
+   "skill": 0.2763,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "22": {
+   "raw": 0.0763,
+   "skill": 0.0691,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0078,
+   "tracks": [],
+   "in_index": true
+  },
+  "23": {
+   "raw": 0.5965,
+   "skill": 0.193,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "24": {
+   "raw": 0.8019,
+   "skill": 0.7359,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "25": {
+   "raw": 0.4082,
+   "skill": 0.2109,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "30": {
+   "raw": 0.6585,
+   "skill": 0.5882,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [
+    {
+     "track": "GSM8K-4choice",
+     "score": 0.7096,
+     "headline": false
+    },
+    {
+     "track": "GSM8K-10choice",
+     "score": 0.6073,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "31": {
+   "raw": 0.2292,
+   "skill": 0.1605,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0819,
+   "tracks": [],
+   "in_index": true
+  },
+  "36": {
+   "raw": 0.177,
+   "skill": 0.1387,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0444,
+   "tracks": [],
+   "in_index": true
+  },
+  "37": {
+   "raw": 0.5199,
+   "skill": 0.3978,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2027,
+   "tracks": [],
+   "in_index": true
+  },
+  "40": {
+   "raw": 0.5057,
+   "skill": 0.3641,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2227,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.3205,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.5057,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.79,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.95,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "41": {
+   "raw": 0.7805,
+   "skill": 0.6707,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3333,
+   "tracks": [],
+   "in_index": true
+  },
+  "43": {
+   "raw": 0.5474,
+   "skill": 0.2819,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3697,
+   "tracks": [],
+   "in_index": true
+  },
+  "44": {
+   "raw": 0.6614,
+   "skill": 0.3228,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "50": {
+   "raw": 0.4553,
+   "skill": 0.2094,
+   "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.8926,
+   "reference_same_cases": null,
+   "median_ms": 139.8,
+   "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.4222,
+   "reference_same_cases": null,
+   "median_ms": 1192.7,
+   "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.8386,
+   "reference_same_cases": null,
+   "median_ms": 640.5,
+   "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.8177,
+   "reference_same_cases": null,
+   "median_ms": 103.1,
+   "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.8381,
+   "reference_same_cases": null,
+   "median_ms": 172.3,
+   "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.7989,
+   "reference_same_cases": null,
+   "median_ms": 392.5,
+   "tracks": {
+    "RouterBench-0shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.7863581850889466,
+     "scored_requests": 5003
+    },
+    "RouterBench-5shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.8114368621172704,
+     "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.3063,
+   "reference_same_cases": null,
+   "median_ms": 1713.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.1982,
+   "reference_same_cases": null,
+   "median_ms": 106.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.8171,
+   "reference_same_cases": null,
+   "median_ms": 2966.1,
+   "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.6899,
+   "reference_same_cases": null,
+   "median_ms": 19.4,
+   "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.8398,
+   "reference_same_cases": null,
+   "median_ms": 18.7,
+   "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.6381,
+   "reference_same_cases": null,
+   "median_ms": 11.8,
+   "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.0825,
+   "reference_same_cases": null,
+   "median_ms": 843.5,
+   "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.5886,
+   "reference_same_cases": null,
+   "median_ms": 50.0,
+   "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.788,
+   "reference_same_cases": null,
+   "median_ms": 18.2,
+   "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.4082,
+   "reference_same_cases": null,
+   "median_ms": 34.6,
+   "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.9798,
+   "reference_same_cases": null,
+   "median_ms": 16.1,
+   "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.9514,
+   "reference_same_cases": null,
+   "median_ms": 16.9,
+   "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.7419,
+   "reference_same_cases": null,
+   "median_ms": 12.0,
+   "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.867,
+   "reference_same_cases": null,
+   "median_ms": 27.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.6585,
+   "reference_same_cases": null,
+   "median_ms": 24.3,
+   "tracks": {
+    "GSM8K-10choice": {
+     "metric": "accuracy",
+     "score": 0.6072782410917361,
+     "scored_requests": 1319
+    },
+    "GSM8K-4choice": {
+     "metric": "accuracy",
+     "score": 0.709628506444276,
+     "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.2292,
+   "reference_same_cases": null,
+   "median_ms": 132.4,
+   "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.5705,
+   "reference_same_cases": null,
+   "median_ms": 93.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.3467,
+   "reference_same_cases": null,
+   "median_ms": 321.2,
+   "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": 21.2,
+   "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.177,
+   "reference_same_cases": null,
+   "median_ms": 1529.6,
+   "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.5199,
+   "reference_same_cases": null,
+   "median_ms": 39.0,
+   "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.0579,
+   "reference_same_cases": null,
+   "median_ms": 978.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.8246,
+   "reference_same_cases": null,
+   "median_ms": 36.0,
+   "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.5057,
+   "reference_same_cases": null,
+   "median_ms": 12.9,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.3205,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.5057,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.79,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.95,
+     "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.7805,
+   "reference_same_cases": null,
+   "median_ms": 23.6,
+   "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.8038,
+   "reference_same_cases": null,
+   "median_ms": 54.9,
+   "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.5474,
+   "reference_same_cases": null,
+   "median_ms": 20.4,
+   "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.6614,
+   "reference_same_cases": null,
+   "median_ms": 19.9,
+   "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.1098,
+   "reference_same_cases": null,
+   "median_ms": 30.4,
+   "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.1795,
+   "reference_same_cases": null,
+   "median_ms": 73.2,
+   "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.4553,
+   "reference_same_cases": null,
+   "median_ms": 81.4,
+   "in_index": true
+  }
+ },
+ "frozen_panel": {
+  "scores": {
+   "balanced_raw": 43.85,
+   "balanced_skill": 31.63,
+   "breadth_skill": 27.36
+  },
+  "categories": [
+   {
+    "id": "knowledge",
+    "raw": 0.6155,
+    "skill": 0.4279,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "language",
+    "raw": 0.5872,
+    "skill": 0.4871,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "tools",
+    "raw": 0.4227,
+    "skill": 0.3486,
+    "coverage": 0.6,
+    "pending": 0.4
+   },
+   {
+    "id": "games",
+    "raw": 0.0458,
+    "skill": 0.0321,
+    "coverage": 0.2,
+    "pending": 0.8
+   },
+   {
+    "id": "arts",
+    "raw": 0.5214,
+    "skill": 0.2859,
+    "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-mimo-9b",
+ "generated_utc": "2026-09-24T14:48:25+00:00",
+ "suite": {
+  "requests": 132422,
+  "scoreable": 131980,
+  "excluded": 442,
+  "benchmarks": 37,
+  "rows_sha256": "750d353a3a83af615c67cfe9752e005bf09e6c28d9c4ba28d3a9f57ba8536cfd"
+ },
+ "completed": 132422,
+ "complete": true,
+ "counts": {
+  "ok": 132422
+ },
+ "latency_ms": {
+  "median": 49.9,
+  "p95": 1129.5,
+  "mean": 251.2
+ },
+ "decision_index": 56.6,
+ "scores": {
+  "balanced_raw": 56.6,
+  "balanced_skill": 42.28,
+  "breadth_skill": 40.47
+ },
+ "areas": [
+  {
+   "id": "knowledge",
+   "label": "Knowledge & Reasoning",
+   "raw": 0.5507,
+   "skill": 0.3832,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 6,
+   "benchmarks": [
+    24,
+    25,
+    30,
+    43,
+    44,
+    31
+   ]
+  },
+  {
+   "id": "language",
+   "label": "Language Understanding",
+   "raw": 0.7036,
+   "skill": 0.5935,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    11,
+    40,
+    41
+   ]
+  },
+  {
+   "id": "retrieval",
+   "label": "Retrieval & Classification",
+   "raw": 0.3487,
+   "skill": 0.2687,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 2,
+   "benchmarks": [
+    36,
+    37
+   ]
+  },
+  {
+   "id": "tools",
+   "label": "Tools & Automation",
+   "raw": 0.7045,
+   "skill": 0.5811,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 3,
+   "benchmarks": [
+    1,
+    2,
+    6
+   ]
+  },
+  {
+   "id": "arts",
+   "label": "Arts & Human Judgment",
+   "raw": 0.5225,
+   "skill": 0.2876,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "n": 5,
+   "benchmarks": [
+    20,
+    21,
+    22,
+    23,
+    50
+   ]
+  }
+ ],
+ "index_benchmarks": {
+  "1": {
+   "raw": 0.8924,
+   "skill": 0.8547,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2594,
+   "tracks": [],
+   "in_index": true
+  },
+  "2": {
+   "raw": 0.4219,
+   "skill": 0.3625,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0933,
+   "tracks": [],
+   "in_index": true
+  },
+  "6": {
+   "raw": 0.7992,
+   "skill": 0.526,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5248,
+   "tracks": [
+    {
+     "track": "RouterBench-0shot",
+     "score": 0.7868,
+     "headline": false
+    },
+    {
+     "track": "RouterBench-5shot",
+     "score": 0.8116,
+     "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.8235,
+   "skill": 0.7448,
+   "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.8424,
+   "skill": 0.6848,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "21": {
+   "raw": 0.6376,
+   "skill": 0.2753,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "22": {
+   "raw": 0.076,
+   "skill": 0.0688,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0078,
+   "tracks": [],
+   "in_index": true
+  },
+  "23": {
+   "raw": 0.5966,
+   "skill": 0.1932,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "24": {
+   "raw": 0.8016,
+   "skill": 0.7355,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "25": {
+   "raw": 0.3953,
+   "skill": 0.1938,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [],
+   "in_index": true
+  },
+  "30": {
+   "raw": 0.6562,
+   "skill": 0.5854,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.25,
+   "tracks": [
+    {
+     "track": "GSM8K-4choice",
+     "score": 0.7069,
+     "headline": false
+    },
+    {
+     "track": "GSM8K-10choice",
+     "score": 0.6054,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "31": {
+   "raw": 0.2291,
+   "skill": 0.1601,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.0821,
+   "tracks": [],
+   "in_index": true
+  },
+  "36": {
+   "raw": 0.1773,
+   "skill": 0.1394,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.044,
+   "tracks": [],
+   "in_index": true
+  },
+  "37": {
+   "raw": 0.5201,
+   "skill": 0.398,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2027,
+   "tracks": [],
+   "in_index": true
+  },
+  "40": {
+   "raw": 0.5081,
+   "skill": 0.3672,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.2227,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.3183,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.5081,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.7889,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.9497,
+     "headline": false
+    }
+   ],
+   "in_index": true
+  },
+  "41": {
+   "raw": 0.7791,
+   "skill": 0.6686,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3333,
+   "tracks": [],
+   "in_index": true
+  },
+  "43": {
+   "raw": 0.5606,
+   "skill": 0.3013,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.3711,
+   "tracks": [],
+   "in_index": true
+  },
+  "44": {
+   "raw": 0.6615,
+   "skill": 0.3229,
+   "coverage": 1.0,
+   "pending": 0.0,
+   "random": 0.5,
+   "tracks": [],
+   "in_index": true
+  },
+  "50": {
+   "raw": 0.4599,
+   "skill": 0.2161,
+   "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.8924,
+   "reference_same_cases": null,
+   "median_ms": 138.9,
+   "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.4219,
+   "reference_same_cases": null,
+   "median_ms": 1193.7,
+   "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.8432,
+   "reference_same_cases": null,
+   "median_ms": 640.3,
+   "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.8162,
+   "reference_same_cases": null,
+   "median_ms": 103.1,
+   "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.8371,
+   "reference_same_cases": null,
+   "median_ms": 172.3,
+   "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.7992,
+   "reference_same_cases": null,
+   "median_ms": 392.5,
+   "tracks": {
+    "RouterBench-0shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.7868085106382978,
+     "scored_requests": 4935
+    },
+    "RouterBench-5shot": {
+     "metric": "selected quality (quality objective)",
+     "score": 0.8116250760803408,
+     "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.2796,
+   "reference_same_cases": null,
+   "median_ms": 1712.7,
+   "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.1939,
+   "reference_same_cases": null,
+   "median_ms": 106.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.8235,
+   "reference_same_cases": null,
+   "median_ms": 2982.4,
+   "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.6905,
+   "reference_same_cases": null,
+   "median_ms": 19.3,
+   "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.842,
+   "reference_same_cases": null,
+   "median_ms": 18.7,
+   "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.6376,
+   "reference_same_cases": null,
+   "median_ms": 11.8,
+   "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.0823,
+   "reference_same_cases": null,
+   "median_ms": 842.8,
+   "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.5883,
+   "reference_same_cases": null,
+   "median_ms": 50.0,
+   "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.7879,
+   "reference_same_cases": null,
+   "median_ms": 18.2,
+   "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.3953,
+   "reference_same_cases": null,
+   "median_ms": 35.2,
+   "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.9801,
+   "reference_same_cases": null,
+   "median_ms": 16.1,
+   "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.9502,
+   "reference_same_cases": null,
+   "median_ms": 16.9,
+   "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.74,
+   "reference_same_cases": null,
+   "median_ms": 12.0,
+   "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.8673,
+   "reference_same_cases": null,
+   "median_ms": 27.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.6562,
+   "reference_same_cases": null,
+   "median_ms": 24.2,
+   "tracks": {
+    "GSM8K-10choice": {
+     "metric": "accuracy",
+     "score": 0.6054313099041534,
+     "scored_requests": 1252
+    },
+    "GSM8K-4choice": {
+     "metric": "accuracy",
+     "score": 0.7068690095846646,
+     "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.2291,
+   "reference_same_cases": null,
+   "median_ms": 132.4,
+   "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.5635,
+   "reference_same_cases": null,
+   "median_ms": 93.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.3462,
+   "reference_same_cases": null,
+   "median_ms": 318.6,
+   "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.1773,
+   "reference_same_cases": null,
+   "median_ms": 1526.9,
+   "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.5201,
+   "reference_same_cases": null,
+   "median_ms": 39.0,
+   "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.0593,
+   "reference_same_cases": null,
+   "median_ms": 978.3,
+   "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.8244,
+   "reference_same_cases": null,
+   "median_ms": 36.2,
+   "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.5081,
+   "reference_same_cases": null,
+   "median_ms": 12.9,
+   "tracks": [
+    {
+     "track": "A \u00b7 Arabic",
+     "score": 0.3183,
+     "headline": false
+    },
+    {
+     "track": "A \u00b7 English",
+     "score": 0.5081,
+     "headline": true
+    },
+    {
+     "track": "C \u00b7 Arabic pairs",
+     "score": 0.7889,
+     "headline": false
+    },
+    {
+     "track": "C \u00b7 English pairs",
+     "score": 0.9497,
+     "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.7791,
+   "reference_same_cases": null,
+   "median_ms": 23.6,
+   "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.8027,
+   "reference_same_cases": null,
+   "median_ms": 54.9,
+   "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.5606,
+   "reference_same_cases": null,
+   "median_ms": 20.3,
+   "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.6615,
+   "reference_same_cases": null,
+   "median_ms": 19.9,
+   "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.1106,
+   "reference_same_cases": null,
+   "median_ms": 30.4,
+   "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.1792,
+   "reference_same_cases": null,
+   "median_ms": 73.2,
+   "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.4599,
+   "reference_same_cases": null,
+   "median_ms": 81.2,
+   "in_index": true
+  }
+ },
+ "frozen_panel": {
+  "scores": {
+   "balanced_raw": 43.89,
+   "balanced_skill": 31.69,
+   "breadth_skill": 27.41
+  },
+  "categories": [
+   {
+    "id": "knowledge",
+    "raw": 0.615,
+    "skill": 0.4278,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "language",
+    "raw": 0.5883,
+    "skill": 0.4886,
+    "coverage": 1.0,
+    "pending": 0.0
+   },
+   {
+    "id": "tools",
+    "raw": 0.4227,
+    "skill": 0.3486,
+    "coverage": 0.6,
+    "pending": 0.4
+   },
+   {
+    "id": "games",
+    "raw": 0.0458,
+    "skill": 0.032,
+    "coverage": 0.2,
+    "pending": 0.8
+   },
+   {
+    "id": "arts",
+    "raw": 0.5225,
+    "skill": 0.2876,
+    "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.9722222222222222,
+  "hard": 0.6936936936936937
+ },
+ "hard_ece": 0.13599638226455113,
+ "prob_tvd": 0.205386479985251,
+ "calibration": 76.13103777428233,
+ "intelligence_public": 79.18539489648231,
+ "input_tokens_per_decision": 694.922077922078,
+ "temperature": 1.0,
+ "hard_by_family": {
+  "adversarial": 1.0,
+  "ambiguous": 1.0,
+  "judge_hard": 0.647,
+  "long_policy": 0.579,
+  "multi_hop": 0.722,
+  "probability": 0.8,
+  "routing_hard": 1.0,
+  "temporal_numeric": 0.333,
+  "tradeoff": 0.5,
+  "trap": 1.0
+ },
+ "p50_s": 0.06154986098408699,
+ "p95_s": 0.2521260780049488,
+ "speed": 87.47933579517849,
+ "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,10 @@
+{
+  "eos_token_id": [
+    248046,
+    248044
+  ],
+  "do_sample": true,
+  "temperature": 0.6,
+  "top_k": 20,
+  "top_p": 0.95
+}

model-00001-of-00004.safetensors

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

model-00002-of-00004.safetensors

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

model-00003-of-00004.safetensors

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

model-00004-of-00004.safetensors

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

model.safetensors.index.json

@@ -0,0 +1,767 @@
+{
+  "metadata": {
+    "total_size": 18819627488
+  },
+  "weight_map": {
+    "model.visual.blocks.8.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.26.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.2.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.dt_bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.10.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.11.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.27.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.9.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.5.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.22.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.31.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.2.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.visual.merger.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.2.mlp.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.9.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.4.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.12.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.20.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.5.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.7.self_attn.q_norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.19.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.17.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.19.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.26.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.5.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.21.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.13.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.9.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.merger.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.11.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.20.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.12.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.15.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.0.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.10.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.11.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.15.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.15.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.19.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.3.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.17.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.9.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.18.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.8.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.31.self_attn.q_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.12.attn.qkv.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.0.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.pos_embed.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.7.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.11.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.22.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.21.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.20.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.3.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.dt_bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.15.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.23.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.19.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.9.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.0.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.0.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.patch_embed.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.4.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.7.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.23.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.18.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.10.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.10.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.15.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.15.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.26.attn.qkv.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.7.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.9.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.5.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.25.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.20.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.23.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.8.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.10.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.15.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.31.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.22.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.25.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.4.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.21.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.24.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.23.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.20.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.merger.norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.20.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.11.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.1.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.10.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.24.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.27.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.23.self_attn.q_norm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.merger.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.1.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.16.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.24.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.3.self_attn.q_norm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.5.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.14.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.20.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.4.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.19.self_attn.q_norm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.8.mlp.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.2.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.24.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.23.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.6.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.8.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.17.mlp.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.22.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.dt_bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.4.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.conv1d.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.21.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.13.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.out_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.7.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.31.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.mlp.linear_fc1.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.15.attn.qkv.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.26.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.mlp.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.1.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.7.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.1.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.1.norm2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.dt_bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.25.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.25.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.23.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.25.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.8.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.1.mlp.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.8.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_b.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.norm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.3.self_attn.o_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.5.norm1.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.22.attn.qkv.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.dt_bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.17.input_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.15.mlp.down_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.13.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.14.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.9.attn.proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_a.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.25.attn.qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.7.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.A_log": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.17.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.25.norm1.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.28.mlp.gate_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.5.mlp.linear_fc2.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_z.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.17.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_qkv.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.22.mlp.linear_fc1.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.3.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.2.norm2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.dt_bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.31.self_attn.k_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.27.self_attn.v_proj.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.16.mlp.up_proj.weight": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.24.attn.proj.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.10.attn.qkv.bias": "model-00001-of-00004.safetensors",
+    "model.visual.blocks.12.mlp.linear_fc2.bias": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.21.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.layers.13.post_attention_layernorm.weight": "model-00001-of-00004.safetensors",
+    "model.language_model.embed_tokens.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.2.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.dt_bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.7.mlp.linear_fc1.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.26.norm1.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.7.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.A_log": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.19.attn.proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.15.attn.proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_z.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.17.attn.proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.14.attn.qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.15.norm1.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.7.attn.proj.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.3.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_qkv.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.17.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.23.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.A_log": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.conv1d.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.21.attn.qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.6.mlp.linear_fc2.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.25.norm2.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_qkv.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_a.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_b.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.25.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.12.norm1.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.6.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.24.norm1.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.A_log": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.A_log": "model-00002-of-00004.safetensors",
+    "model.visual.patch_embed.proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.19.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_a.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.11.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.30.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.A_log": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_a.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.conv1d.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.4.norm2.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.norm.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.23.norm2.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.17.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.17.norm1.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_b.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.13.mlp.linear_fc2.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.18.mlp.linear_fc1.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.26.post_attention_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.2.norm1.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.13.norm1.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.10.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_qkv.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.out_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.16.mlp.linear_fc2.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.16.mlp.linear_fc2.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.norm.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.12.attn.proj.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.6.norm1.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.22.mlp.linear_fc2.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.21.attn.proj.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.dt_bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.16.attn.qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.22.attn.qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.4.norm2.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.out_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.out_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.3.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.3.attn.proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.dt_bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.24.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.18.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.21.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.16.mlp.linear_fc1.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.6.mlp.linear_fc2.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.25.mlp.down_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.11.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.9.attn.proj.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.10.mlp.linear_fc2.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.11.mlp.up_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.10.mlp.linear_fc2.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.dt_bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.9.mlp.linear_fc1.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.4.mlp.linear_fc2.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.2.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.19.self_attn.q_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.19.norm2.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.11.norm1.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.12.mlp.linear_fc1.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.19.self_attn.o_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_z.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.norm.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.8.mlp.linear_fc1.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.15.self_attn.k_proj.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.dt_bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.21.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.3.self_attn.k_norm.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.16.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.7.input_layernorm.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.5.mlp.gate_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.21.mlp.linear_fc1.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_z.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.out_proj.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.20.attn.qkv.weight": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.20.attn.qkv.bias": "model-00002-of-00004.safetensors",
+    "model.visual.blocks.6.mlp.linear_fc1.weight": "model-00002-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.dt_bias": "model-00002-of-00004.safetensors",
+    "lm_head.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.6.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.23.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.13.attn.qkv.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_a.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.0.mlp.linear_fc1.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.3.self_attn.v_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_qkv.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.21.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.3.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.21.norm2.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.12.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.1.mlp.linear_fc1.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_z.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.28.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.17.norm2.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.11.attn.proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.norm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.out_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.27.self_attn.q_norm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.1.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.24.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.26.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.4.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.26.mlp.linear_fc2.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.5.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.19.norm1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.23.self_attn.q_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.25.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.4.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.29.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.19.mlp.linear_fc1.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.25.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.30.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.16.norm1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.conv1d.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.2.norm1.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.17.mlp.linear_fc1.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.4.mlp.linear_fc1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.6.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.13.attn.qkv.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.5.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.20.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.6.attn.qkv.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.16.norm2.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.10.attn.qkv.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.18.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.28.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.10.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.11.norm2.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.norm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.15.mlp.linear_fc1.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.A_log": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.16.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.20.norm2.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.5.attn.proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.conv1d.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.conv1d.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.19.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.0.norm1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.2.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.18.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.11.attn.qkv.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.in_proj_qkv.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.19.attn.qkv.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.19.mlp.linear_fc2.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.16.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.norm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.11.mlp.linear_fc2.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.4.mlp.linear_fc2.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.18.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.16.attn.proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.in_proj_a.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.0.attn.qkv.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.7.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.24.mlp.linear_fc1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_z.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.24.norm2.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.16.norm1.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.1.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.23.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.22.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.12.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.13.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.31.self_attn.q_norm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.23.mlp.linear_fc1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.in_proj_z.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.3.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.21.norm1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.12.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.12.norm2.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.12.mlp.linear_fc1.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.22.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.4.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.11.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.3.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.5.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.dt_bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.0.mlp.linear_fc2.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.conv1d.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.norm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.18.norm2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.20.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.0.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.22.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.29.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.21.mlp.linear_fc1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.7.self_attn.k_norm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.22.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.25.norm1.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.15.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.4.attn.qkv.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.dt_bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.20.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.27.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_qkv.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.24.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.7.mlp.up_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_z.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.3.attn.qkv.bias": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.17.norm1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.conv1d.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.14.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.24.attn.qkv.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.14.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.A_log": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.13.attn.proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_z.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.18.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.10.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.25.attn.proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.27.self_attn.o_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.0.attn.proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.7.mlp.linear_fc2.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.9.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.27.mlp.down_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.15.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.23.self_attn.k_proj.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.14.norm1.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.in_proj_b.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.30.post_attention_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.visual.blocks.8.attn.proj.bias": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.A_log": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.conv1d.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.in_proj_a.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.29.input_layernorm.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.11.mlp.gate_proj.weight": "model-00003-of-00004.safetensors",
+    "model.language_model.layers.12.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_b.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.conv1d.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.26.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.9.mlp.linear_fc2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.6.attn.proj.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.19.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.5.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.8.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.7.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.1.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.15.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.15.self_attn.q_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.12.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.25.attn.proj.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.22.linear_attn.in_proj_z.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.16.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.11.self_attn.k_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.in_proj_z.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.3.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.15.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.5.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.7.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.23.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.18.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.13.mlp.linear_fc2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.8.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.7.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.conv1d.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.15.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.2.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.24.mlp.linear_fc2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.23.mlp.linear_fc2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.23.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.14.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.9.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.26.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.29.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.18.attn.proj.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.8.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.19.self_attn.k_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.19.self_attn.k_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.18.mlp.linear_fc2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.31.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.16.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.31.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.2.mlp.linear_fc2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.14.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.5.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.8.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.4.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.15.self_attn.k_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.5.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_b.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.11.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.13.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.0.attn.proj.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.8.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.16.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.31.self_attn.o_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.conv1d.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.26.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.26.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.23.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.2.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.0.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.6.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.6.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.31.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_z.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.26.mlp.linear_fc2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.24.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.22.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.18.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.11.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.9.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.7.self_attn.k_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.9.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.26.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.10.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.24.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.25.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.conv1d.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.6.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.27.self_attn.k_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.22.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.5.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.23.self_attn.k_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.1.mlp.linear_fc2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.1.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.12.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.18.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.13.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.7.self_attn.q_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.21.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.24.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.27.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.30.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.16.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.19.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.3.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.5.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.16.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.13.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.27.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.9.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.2.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.conv1d.weight": "model-00004-of-00004.safetensors",
+    "model.visual.merger.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.20.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_b.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.13.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.19.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.6.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.19.self_attn.v_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_z.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.12.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.10.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.11.self_attn.o_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.4.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.3.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.31.self_attn.k_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.25.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.4.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.9.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.0.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.28.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.15.self_attn.o_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.28.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.20.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.26.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.26.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.15.self_attn.q_norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.26.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.23.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.23.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.22.norm2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.20.linear_attn.A_log": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.1.attn.qkv.weight": "model-00004-of-00004.safetensors",
+    "model.visual.merger.norm.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.30.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.6.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.22.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.19.mlp.linear_fc2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.2.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.11.attn.proj.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.9.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.23.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.12.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.24.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.23.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.25.mlp.up_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.20.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.27.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.28.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.1.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.14.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.out_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.0.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.9.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_z.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.0.mlp.down_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.1.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.11.self_attn.q_norm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.2.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.10.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.17.mlp.linear_fc2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.21.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.7.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.20.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.4.linear_attn.conv1d.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.15.mlp.linear_fc2.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.29.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.17.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.24.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.26.linear_attn.dt_bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.19.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.22.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.10.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.7.norm1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.1.attn.proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.8.mlp.linear_fc1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.30.input_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.21.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.10.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.7.mlp.linear_fc1.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_a.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.1.attn.qkv.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.29.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.13.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.18.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.17.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.11.norm1.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.14.linear_attn.in_proj_qkv.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.8.linear_attn.in_proj_z.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.11.self_attn.q_proj.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.21.linear_attn.norm.weight": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.12.post_attention_layernorm.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.6.norm2.bias": "model-00004-of-00004.safetensors",
+    "model.language_model.layers.14.mlp.gate_proj.weight": "model-00004-of-00004.safetensors",
+    "model.visual.blocks.0.mlp.linear_fc2.weight": "model-00004-of-00004.safetensors"
+  }
+}

preprocessor_config.json

@@ -0,0 +1,26 @@
+{
+  "do_convert_rgb": true,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "Qwen2VLImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "merge_size": 2,
+  "patch_size": 16,
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "longest_edge": 16777216,
+    "shortest_edge": 65536
+  },
+  "temporal_patch_size": 2
+}

processor_config.json

@@ -0,0 +1,60 @@
+{
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_processor_type": "Qwen2VLImageProcessor",
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "merge_size": 2,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 16777216,
+      "shortest_edge": 65536
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Qwen3VLProcessor",
+  "video_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "fps": 2,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "max_frames": 768,
+    "merge_size": 2,
+    "min_frames": 4,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 25165824,
+      "shortest_edge": 4096
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Qwen3VLVideoProcessor"
+  }
+}

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,33 @@
+{
+  "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+",
+  "processor_class": "Qwen3VLProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

video_preprocessor_config.json

@@ -0,0 +1,21 @@
+{
+    "size": {
+        "longest_edge": 25165824,
+        "shortest_edge": 4096
+    },
+    "patch_size": 16,
+    "temporal_patch_size": 2,
+    "merge_size": 2,
+    "image_mean": [
+        0.5,
+        0.5,
+        0.5
+    ],
+    "image_std": [
+        0.5,
+        0.5,
+        0.5
+    ],
+    "processor_class": "Qwen3VLProcessor",
+    "video_processor_type": "Qwen3VLVideoProcessor"
+}

weights.sha256

@@ -0,0 +1,15 @@
+59a64ebb4df6d1489d09a91267cf3ceb106162d4a893c4f84833cfb8c897ff63  chat_template.jinja
+407c46388b8fa2ae9bf69fe27d40af236d373e86a6b48f5284c86df5cd183633  config.json
+aaed5b26f1cae55c1ceb58fc483c3cd65ee8d386b61daec3d7a9df82432d9205  generation_config.json
+a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d  merges.txt
+9da483e4c921f161562d994709fe7181a05d1a14692026d9943da80021247d82  model-00001-of-00004.safetensors
+efbf9af22c3f00f32289c50f9cd9ed5abc6cf9ab4af957d9adae1c80cd0daeae  model-00002-of-00004.safetensors
+3fb71b091963d851c95352c3d3a24ecefc114a3b281e916943a129f173db05d7  model-00003-of-00004.safetensors
+6c8a6365689c40acdf1c7605819323cd09f7f5f8818497e9cd56f50b7ef38d34  model-00004-of-00004.safetensors
+39fd8a226de2d7e132ef77547c3ec772368f329718da4d4808d4dd7dbe4fbd2e  model.safetensors.index.json
+3a159dfec9978a186a72ba085e0ad6a050f3968d8b364218d7bd13f5c89381f2  preprocessor_config.json
+d89ef49ce9cd37fbf510158e13c1ef063d9286411c1ec9049932dbe0487143b1  processor_config.json
+06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523  tokenizer.json
+792fa3f0cb88b111e54ef3134c873531008c4df471d108da17903426e308aa7b  tokenizer_config.json
+7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13  video_preprocessor_config.json
+ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003  vocab.json