Kev-0.8B on Core AI: fp16 S=16 hidden-state decoder (.aimodel) with the pointer head, tokenizer, card, config, adapter_config, LICENSE and SHA256SUMS

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* 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
+gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+gpu-pipelined/kev_0_8b_decode_fp16_pf16/tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -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.

README.md

@@ -0,0 +1,428 @@
+---
+license: apache-2.0
+base_model: jaredpalmer/kev-0.8b
+base_model_relation: quantized
+pipeline_tag: text-classification
+library_name: coreai
+language:
+- en
+tags:
+- coreai
+- core-ai
+- apple
+- on-device
+- iphone
+- decision-model
+- systemone
+- typed-decisions
+- structured-output
+---
+
+# Kev-0.8B — Core AI
+
+Apple Core AI (`.aimodel`) conversion of [jaredpalmer/kev-0.8b](https://huggingface.co/jaredpalmer/kev-0.8b/tree/bf75a6a8848ea6960ff2ed108d9ed44c2941174f) (tag `v1.0`, Apache-2.0): a state and typed questions in, the probability of every option of every question out.
+
+| Variant | Path | Size | Requires | Tested on |
+|---|---|---:|---|---|
+| Decoder, fp16, with the host's pointer head | `gpu-pipelined/kev_0_8b_decode_fp16_pf16/` | 1,521 MB | macOS 27 / iOS 27 | M4 Max, macOS 27.0 (26A428), 2026-10-03; iPhone 18 Pro, iOS 27.0 (24A437), 2026-10-04 |
+
+One question of 94 tokens takes 112 ms on the M4 Max and 157 ms on the iPhone 18 Pro, in Swift ([measured below](#time-per-decision-on-the-mac)).
+
+```swift
+import Kev
+
+let bundle = URL(filePath: "Kev-0.8B-CoreAI/gpu-pipelined/kev_0_8b_decode_fp16_pf16")
+let kev = try await KevDecider(bundle: bundle)              // asset: nil = the .aimodel, specialized here (GPU, frequent reshapes)
+let response = try await kev.decide(requestJSON: requestData, shared: true)   // shared: the state's chunks run once
+print(PythonFormat.dumps(response, asciiOnly: false))
+```
+
+The snippet uses the [`Kev`](https://github.com/john-rocky/coreai-model-zoo/tree/main/apps/Kev) Swift package from the model zoo. The zoo card and the gate scripts live in [coreai-model-zoo](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/README.md); the rest of this page is the same text with repository links.
+
+Source [jaredpalmer/kev-0.8b](https://huggingface.co/jaredpalmer/kev-0.8b/tree/bf75a6a8848ea6960ff2ed108d9ed44c2941174f) (tag `v1.0`, commit `bf75a6a`) · base [Qwen/Qwen3.5-0.8B-Base](https://huggingface.co/Qwen/Qwen3.5-0.8B-Base/tree/dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68) (revision `dc7cdfe`)
+
+A **decision model**. Give it a state (text, or a JSON object or array) and typed questions: `noul`
+(yes / no), `choice` (named options) or `score` (ordered levels). It returns a probability for every
+option of every question. It never generates text. Requests and responses use the SystemOne-compatible
+request shape: `{model, state, questions}` in, `{model, answers, usage}` out, one typed decision per
+question.
+
+Jared Palmer trained it as a rank-16 LoRA adapter and a pointer head on Qwen3.5-0.8B-Base (24 layers:
+18 Gated DeltaNet and 6 full attention, hidden size 1,024). The author's card: "It reads one document
+(the *state*) and a set of typed questions about it, and returns a calibrated probability distribution
+over the options supplied with each question, in a single forward pass and without generating text."
+Each question is its own row: the state, then the question and its options. The head scores each
+option's closing token against the question's last token. The author's card reports benchmark
+results; none of them are re-measured here.
+
+This port merges the adapter into the base with the author's own merge script and exports the text
+backbone as one Core AI graph. The graph takes token ids, 16 per call, and returns the final-norm
+hidden state at every position; it has no vocabulary head. Weights are fp16 (1.51 GB). The host runs
+the pointer head from the author's head weights. The gate is probability parity with the author's own
+fp32 code, on every option of every question, on a fixture of 434 questions and on a held-out set of
+130.
+
+It runs on the Mac GPU and on an iPhone 18 Pro. On the phone the shipped `.aimodel` is specialized on
+the device; an AOT asset compiled for the phone's GPU (not shipped) was measured too.
+
+## Readout contract
+
+One row per question, every row from zeroed states. The ids are the author's `kev.model.encode` in its
+row form (`rows_of`), with the base model's tokenizer:
+
+```
+[<|fim_prefix|>] + render(state) + [<|fim_middle|>] + render(instructions)
+  + for each option: [<|box_start|>] + option_text + [<|box_end|>]
+  + [<|fim_suffix|>]
+```
+
+- Delimiters, from the base tokenizer: `<|fim_prefix|>` 248060 (state), `<|fim_middle|>` 248061
+  (question), `<|box_start|>` 248049 / `<|box_end|>` 248050 (an option), `<|fim_suffix|>` 248062
+  (decide). Pad = eos = `<|endoftext|>` 248044; no bos. The `kev-4b` repository still carries Qwen3-era
+  `added_tokens.json` with other ids; the author's loader reads the tokenizer from the base, and so
+  does this port.
+- User text is tokenized without special tokens after `<|name|>` is rewritten to `<¦name¦>`
+  (`user_tokens`), so a request can never produce a delimiter.
+- `render()` (`kev.api.to_record`): a string as is; an object or an array as `key: value` lines (`- `
+  for array items, nesting indented by two spaces), values as Python's `str()`. Options: `noul` =
+  `no[: <criteria.false>]`, `yes[: <criteria.true>]`, in that order; `choice` = `name` or
+  `name: <description>` in criteria order; `score` = the levels in order. Keys: `choice` = the criteria
+  names, `noul` = `false`, `true`, `score` = `"0"`..`"n-1"`.
+- The head reads the hidden state at `<|fim_suffix|>` (the row's last token) and at every
+  `<|box_end|>`: `z_k = ((W_k h_opt_k + b_k) · (W_q h_decide + b_q)) / 16`, `p = softmax(z / T)` within
+  the question, T = 2.3510958125672174 (the author's calibration, stored in `head.pt`). `W_q`, `W_k`
+  are `[256, 1024]` with biases, fp32.
+- Response (`kev.api.to_answers`): `noul` → p(true); `choice` → the argmax key, a confidence
+  `(p_max − 1/K) / (1 − 1/K)` and every p; `score` → Σ level · p, the legend, every p and a confidence
+  `max(0, 1 − E|level − mode| / D)`; values rounded to 4 decimals. `usage` = `{input_tokens,
+  output_tokens}` with the author's counting (the packed request; the tokens of `json.dumps(answers)`).
+- Length: a row holds at most **4,080 tokens** (the last padded call must end below the graph's 4,095
+  position bound). The author's server accepts states of 65,536 tokens; here a longer row is refused
+  before any call.
+- Shared prefix (optional, exact): every row of a request starts with the same state tokens, so the
+  first ⌊Ls / 16⌋ chunks can run once, the four states be copied per question, and each row continue
+  from there. Every row's hidden state equals its direct run bit for bit (below).
+
+`conversion/kev/oracle_kev.py` runs the author's package unchanged (`Checkpoint.load("cpu", fp32)`,
+`kev.model.admit`, the row-form `forward`, one CPU thread) and records the reference:
+[`fixtures-kev-0.8b.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/fixtures-kev-0.8b.json). The fixture is 384 records and 434 questions:
+the first 60 lines of the author's transfer-v4 development file (`evals/v4/transfer-v4/development.jsonl`,
+tag `kev-1.0`; MMLU, 4 options), the first 20 records of each of its seven other sources (140, `choice`
+and `noul`), its first 20 `score` records, the 144 `choice` items of SemIf authored144, and 20 records
+written for the port (70 questions: `noul`, `choice` with 2–10 options, `score` with 2–7 levels,
+JSON states, three states of 1,431–1,746 tokens, one record of 8 questions). The longest row is 1,802
+tokens. Fourteen questions have an oracle top-2 margin of 0.02 or less (near-ties) and are listed apart.
+The held-out set is the next 130 transfer-v4 records (mmlu 61–100, records 21–30 of each other source,
+`score` records 21–40), with its own oracle run.
+
+## Core AI shape
+
+`conversion/kev/qwen3_5_kev_decoder.py`: the overlay's stateful Qwen3.5 text decoder
+(`Qwen3_5StatefulForCausalLM`) on the merged weights, the vocabulary head replaced by the identity, the
+output the final-norm hidden state at every position. One function, `main`, at a static 16 tokens; the
+Gated DeltaNet recurrence is unrolled in the graph.
+
+| | name | shape, type |
+|---|---|---|
+| inputs | `input_ids` | [1, 16] int32 |
+| | `position_ids` | [1, seq] int32, the ramp 0 .. seq − 1 |
+| states | `keyCache`, `valueCache` | [6, 1, 2, ctx, 256] fp16, ctx up to 4,096 |
+| | `convState`, `recState` | [18, 1, 6144, 3], [18, 1, 16, 128, 128] fp16 |
+| output | `hidden` | [1, 16, 1024] fp16, every position |
+
+Per row of T ids, from zeroed states: ⌈T / 16⌉ calls, call k with ids[16k : 16k + 16] and position_ids
+0..16k + 15; the last call is padded with `<|endoftext|>` (248044) and its padded rows are dropped. The
+rows of every call, cut to T, are the backbone's final-norm `last_hidden_state [T, 1024]`. The bundle's
+`metadata.json` says `kind: decision-backbone` and carries this order, the row layout, the delimiter ids,
+the render rules, the head formula and the response shape.
+
+**Host.** Builds the rows, runs the calls, converts the hidden rows at the readout positions to float64,
+applies the head (`head/head.safetensors`, `head/kev_head.json`) and the per-question softmax in float64,
+rounds p to fp32 once, and writes the response. `conversion/kev/decide.py` is the Python reference;
+[`apps/Kev`](https://github.com/john-rocky/coreai-model-zoo/tree/main/apps/Kev) is the Swift one.
+
+No engine is involved: the hosts drive the low-level runtime (`AIModel` + `loadFunction`, four zeroed
+states per row). No runtime patch.
+
+## Measured (Apple M4 Max, macOS 27.0 26A428, 2026-10-03 – 10-04)
+
+The bar, fixed before any graph ran: the argmax equal to the oracle's on every question whose oracle
+top-2 margin is above 0.02 (near-ties listed apart), max |Δp| ≤ 0.02 over every option of every
+question, the mean over rows of each row's mean |Δp| ≤ 0.002, and every process re-running its first row
+bit for bit. The Python gates load the AOT `.aimodelc` (`coreai-build compile … --platform macOS
+--preferred-compute gpu --architecture h16c --expect-frequent-reshapes`) with
+`SpecializationOptions.default()`; their times are on a GPU shared with other work.
+
+### Before any graph: the merge and fp32 torch
+
+- The merged checkpoint (`scripts/merge_lora_checkpoint.py`, tag `kev-1.0`; fp32, 320 tensors, 186 of
+  them adapted, `model.safetensors` sha256 `b5ebf92a…`) answers through the author's own loader as the
+  adapter checkpoint does: 434/434 questions, logits bit-equal. `W + (B @ A) × 2` reproduces three
+  merged tensors bit for bit (the adapter moves them by 2.8–3.6 %). The base alone moves p by up to
+  0.789 (argmax 25/53), the base's Gated DeltaNet projections put back by up to 0.282 (46/53): the
+  check can fail ([`gate-kev-0.8b-merge.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-merge.json)).
+- The decoder module in fp32 on the CPU, driven like the graph, read through the author's head: 434/434
+  argmax (the 14 near-ties included), max |Δp| 3.5e-6, lowest per-position hidden cosine 0.99999999999
+  on the 21 rows the oracle keeps. It equals the overlay's plain text decoder bit for bit (3 rows), and
+  S = 32, 64 and 128 give the bits of S = 16
+  ([`gate-kev-0.8b-torch-parity.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-torch-parity.json)).
+
+### The graph alone on the Mac GPU
+
+The oracle's ids in, the fp16 hidden rows read through the author's fp32 head:
+
+| set | questions | argmax (margin > 0.02) | near-ties agreeing | max \|Δp\| | mean of row means | bar |
+|---|---:|---:|---:|---:|---:|---|
+| **fixture** | 434 | **420/420** | **12/14** | **0.0117** | **0.00097** | **PASS** |
+| held out | 130 | 125/125 | 5/5 | 0.0057 | 0.00081 | PASS |
+
+The two near-ties that flip are `tv4_023` (oracle margin 0.0020) and a SemIf item (0.0032), each by at
+most 0.0027. The worst row is a SemIf item (0.0117). Every value is finite and every process's re-run is
+bit-equal. Two red arms move p on the same graph: a state swapped for another record's moves 4 of 5
+argmaxes (max |Δp| 0.905); a grammatical "not" in five yes / no questions moves 2 of 5 (0.759); fp32
+torch moves the same rows by the same amounts. Transcripts:
+[`gate-kev-0.8b-readout-fp16_pf16.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-readout-fp16_pf16.json),
+[`gate-kev-0.8b-heldout.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-heldout.json).
+
+### From the request: Python and Swift
+
+- `conversion/kev/host.py`, without the author's package, rebuilds every oracle row from the raw
+  request (ids, `<|fim_suffix|>` / `<|box_end|>` indices, keys): 564/564 rows with two tokenizer
+  implementations; fed the oracle's p, its response bodies equal the author's on every record but
+  `latency_ms`. `decide.py` on the AOT graph: hidden rows bit-equal to the gate's on 564/564 rows; the
+  shared prefix equal to the direct run on every row, the 20 multi-question records taking 662 calls
+  instead of 1,830 ([`gate-kev-0.8b-host.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-host.json)).
+- The Swift host ([`apps/Kev`](https://github.com/john-rocky/coreai-model-zoo/tree/main/apps/Kev), Release): ids from the raw request 564/564; on the same
+  AOT asset every row's hidden state, every p and every answer set's `json.dumps` equal the Python
+  reference's bit for bit and byte for byte, and the bar is the gate's (fixture 0.0117 / 0.00097, held
+  out 0.0057 / 0.00081). Its text half equals CPython on 2,787 rendered values, 599 requests (21 refused
+  with the same messages), 203,635 doubles (`str`, `repr`, `round`) and 1,093 `json.dumps` texts. One
+  word changed in one question turns its record red.
+- JIT: the `.aimodel` specialized by the Swift runtime (GPU preferred, `expectFrequentReshapes`) equals
+  the AOT asset bit for bit on 25 rows of 10 records; the specialization took 5.4 s and added
+  2,510,934,016 bytes to the runtime's cache.
+- Rows near the limit (a diagnosis, not a gate set): rows of 4,072, 4,030, 3,039 and 2,997 tokens built
+  from the fixture's long states keep every argmax, max |Δp| 0.0023, and the hidden state's cosine to
+  the oracle's is at least 0.99994 at every position
+  ([`gate-kev-0.8b-swift.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-swift.json)).
+
+### iPhone 18 Pro (iOS 27.0 24A437, Core AI arch h19p, 2026-10-04)
+
+Through [`apps/KevGate`](https://github.com/john-rocky/coreai-model-zoo/tree/main/apps/KevGate), a headless gate app on the Swift host, Release, without the
+increased-memory-limit entitlement (3,529 MB available at launch). The phone was on USB power, the
+battery at 80 % and charging; every bench item started at thermal state nominal. Every p the app wrote
+was re-scored on the Mac from its bit patterns.
+
+| load | cache | wall s | `AIModel` s | `main` s | runtime cache added | peak footprint |
+|---|---|---:|---:|---:|---:|---:|
+| `.aimodel` specialized on the phone (GPU preferred, `expectFrequentReshapes`) | cold | 6.65 | 5.87 | 0.42 | 2,505,661,047 B | 316 MB |
+| the same | warm | 0.61 | 0.00 | 0.25 | 0 | 216 MB |
+| h19p AOT asset (2,505,674,625 B), `.default` | cold | 4.64 | 3.07 | 1.22 | 2,505,681,950 B | 223 MB |
+
+| set | asset | questions | argmax (margin > 0.02) | near-ties agreeing | max \|Δp\| | mean | bar |
+|---|---|---:|---:|---:|---:|---:|---|
+| fixture | specialized on the phone | 434 | 420/420 | 13/14 | 0.0102 | 0.00098 | PASS |
+| held out | specialized on the phone | 130 | 125/125 | 5/5 | 0.0049 | 0.00083 | PASS |
+| fixture 60 + held out 30 | h19p AOT | 90 | 80/80 | 10/10 | 0.0071 | 0.00078 | PASS |
+
+On the phone the AOT asset and the device specialization agree bit for bit (90/90 rows). No hidden row
+is bit-equal to the Mac's (M4 Max, AOT h16c): their p differ by at most 0.0027, and one near-tie
+(`tv4_023`, oracle margin 0.0020) lands on the oracle's side on the phone and not on the Mac. The shared prefix equals the direct run on
+all 20 multi-question records. The first decision after the cold specialization took 3.58 s; in the bench
+below a 16-token call's median was 25.9–26.6 ms on every item, whatever the row length.
+
+Bench (60 s of rest before each item, one warm-up, then the decisions back to back; `latency_ms` = state
+resets, graph calls and the head):
+
+| request | tokens | calls | median ms (specialized on the phone) | runs | h19p AOT median ms |
+|---|---:|---:|---:|---|---:|
+| one question (`tv4_000`) | 94 | 6 | 156.6 | 5: 156.3–157.3 | 157.2 |
+| one question (`own_j03` q0) | 380 | 24 | 629.2 | 5: 628.9–630.1 | 627.8 |
+| one question (`own_L02` q0) | 1,518 | 95 | 2,500.0 | 5: 2,499.4–2,502.5 | — |
+| one question (`own_L01` q2) | 1,802 | 113 | 2,975.9 | 5: 2,974.1–2,981.4 | — |
+| 5 questions, 137-token state (`own_m01`), direct | 240 | 51 | 1,330.5 | 5: 1,329.1–1,333.5 | — |
+| the same, shared prefix | 240 | 19 | 507.8 | 5: 507.1–508.8 | 508.2 |
+| 8 questions (`own_m01`), direct | 320 | 83 | 2,167.5 | 3: 2,163.8–2,182.6 | — |
+| the same, shared prefix | 320 | 27 | 722.4 | 3: 721.2–732.9 | — |
+| 4 questions, 1,477-token state (`own_L02`), direct | 1,622 | 380 | 10,026.3 | 2: 10,018.3–10,034.3 | — |
+| the same, shared prefix | 1,622 | 104 | 2,761.9 | 2: 2,752.4–2,771.5 | — |
+
+The last item ran 38 s back to back and ended at thermal state fair. Kev-4B on the phone: see the
+[Kev-4B card](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-4b/README.md). Transcript: [`gate-kev-0.8b-iphone.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-iphone.json).
+
+### Time per decision on the Mac
+
+Swift, Release CLI, AOT asset, in one machine-wide GPU lock window (2026-10-04 00:11–00:33 JST) with no
+other GPU job and a CPU load of 4–10. A B A B: two processes, one warm-up, the median over 20 decisions
+(p10–p90):
+
+| request | tokens | calls | ms | p10–p90 |
+|---|---:|---:|---:|---|
+| one question (`tv4_000`) | 94 | 6 | 112.1 | 103.2–166.5 |
+| one question (`own_j03` q0) | 380 | 24 | 472.0 | 413.9–583.1 |
+| one question (`own_L02` q0) | 1,518 | 95 | 1,595.4 | 1,567.5–1,660.8 |
+| one question (`own_L01` q2) | 1,802 | 113 | 1,915.0 | 1,875.8–2,117.4 |
+| 5 questions (`own_m01`), direct / shared prefix | 240 | 51 / 19 | 879.9 / 342.3 | 835.3–917.1 / 323.0–345.4 |
+| 8 questions (`own_m01`), direct / shared prefix | 320 | 83 / 27 | 1,454.7 / 484.5 | 1,384.9–1,555.2 / 454.9–496.6 |
+| 4 questions (`own_L02`), direct / shared prefix | 1,622 | 380 / 104 | 6,415.3 / 1,785.0 | 6,266.8–6,733.8 / 1,733.2–1,884.7 |
+
+A 16-token call took 18.6 and 17.2 ms (the two processes' medians). Loading the AOT asset with the
+runtime's cache warm: 0.61 / 0.27 s at each process's first load, 0.43 / 0.24 s at its second. The Python
+reference in the same window: 104.0 ms for `tv4_000` and 347.5 ms for five questions with the shared
+prefix. Transcript: [`gate-kev-0.8b-timing-mac.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-timing-mac.json).
+
+## Precision
+
+**int8 was measured and is not shipped.** int8 per block of 32 over every decoder linear
+(`symmetric_with_clipping`, weights only; the embedding table, the Gated DeltaNet conv1d and every norm
+fp16) fails the bar:
+
+| decoder | `main.mlirb` bytes | fixture max \|Δp\| / mean | held out max \|Δp\| / mean | bar |
+|---|---:|---:|---:|---|
+| fp16 (shipped) | 1,506,481,909 | 0.0117 / 0.00097 | 0.0057 / 0.00081 | PASS |
+| int8lin: every linear int8 | 1,040,063,350 | 0.0431 / 0.00326 | 0.0273 / 0.00294 | FAIL |
+| int8mix: int8 except layers 0–11 | 1,273,276,920 | 0.0089 / 0.00103 | 0.0043 / 0.00082 | PASS |
+
+int8lin breaks the bar on 10 fixture rows (above 0.01: 51 rows; fp16: 1). An fp32 torch bisect with the
+exporter's own int8 weights (`conversion/kev/int8_bisect_torch.py`, 60 rows) reproduces it (0.0420
+against the graph's 0.0431). Its rule, written before any result, asked for the worst row below 0.010
+with at most half of the linear weights kept fp16; no set met it (the best: four kinds of linear kept
+fp16, 45.5 % of the weights, 0.0141). Layers 0–11 kept fp16, exactly half and outside the rule's search,
+give 0.0046 on the bisect rows; that is int8mix. It keeps 85 % of fp16's bytes, and it was chosen on the
+fixture, so it does not ship ([`gate-kev-0.8b-int8.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-int8.json)).
+
+**What the compiled asset holds.** `--expect-frequent-reshapes`, which this dynamic-length graph needs to
+run without re-specializing, adds an fp16 copy of every linear weight to the compiled asset: the iPhone
+h19p asset is 2,505,674,625 bytes with it and 1,506,400,620 without. On a toy (an embedding and two
+linears) compiled with a fixed input length, the int8 version's `resources.bin` is 12,582,936 bytes on
+macOS and iOS, with and without the flag, the bytes of the fp16 toy compiled without it, against an int8
+`main.mlirb` of 10,623,080 bytes. An int8 `.aimodel` downloads smaller; the compiled asset is not
+smaller by the same amount
+([`../kev-4b/gate-kev-4b-int8.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-4b/gate-kev-4b-int8.json)).
+
+**Chunk width.** S = 16, 32, 64 and 128 all pass the bar (max |Δp| 0.0117, 0.0118, 0.0100, and 0.0060 on
+130 rows). A call's time grows with S: the Gated DeltaNet layers run their S steps one after another
+inside the call. In one interleaved run over the fixture's 423 warm rows, S = 16 took 72.8 s of graph
+calls and S = 32 74.4 s, and S = 16 pads 5.1 % of the fixture against 10.4 %. S = 16 ships
+([`gate-kev-0.8b-readout-s.json`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/gate-kev-0.8b-readout-s.json)).
+
+## ⬇️ Bundle
+
+[mlboydaisuke/Kev-0.8B-CoreAI](https://huggingface.co/mlboydaisuke/Kev-0.8B-CoreAI), one folder under
+`gpu-pipelined/`:
+
+| file | what | bytes | sha256 |
+|---|---|---:|---|
+| `kev_0_8b_decode_fp16_pf16.aimodel/main.mlirb` | the decoder, fp16 | 1,506,481,909 | `4131d028…72682d` |
+| `metadata.json` | `kind: decision-backbone`, the readout contract, the gate | 15,236 | `97b70e43…22b65b2` |
+| `tokenizer/tokenizer.json` | the base model's, verbatim | 12,807,196 | `fe000e3e…d50d2927` |
+| `tokenizer/tokenizer_config.json` | the base model's, verbatim | 16,712 | `e611fbcc…c47885de` |
+| `head/head.safetensors` | the pointer head: q / k weight `[256, 1024]` and bias, fp32 | 2,099,576 | `12038b02…700893a42` |
+| `head/kev_head.json` | head size, scale, temperature, delimiter ids, provenance | 2,046 | `73d51070…99d5c9d7c` |
+
+The repository root carries the base model's `config.json`, the adapter's `adapter_config.json` and the
+Apache-2.0 `LICENSE`, verbatim. `SHA256SUMS` lists every file. The Hub revision is recorded here after the
+upload.
+
+No AOT asset ships: the Swift runtime specializes the `.aimodel` correctly on the Mac and on the phone (the
+JIT rows above). To compile one anyway:
+
+```bash
+xcrun coreai-build compile kev_0_8b_decode_fp16_pf16.aimodel --output aot --preferred-compute gpu \
+    --platform macOS --architecture h16c --expect-frequent-reshapes     # iPhone 18 Pro: --platform iOS --architecture h19p
+```
+
+`--expect-frequent-reshapes` is required (without it the runtime specializes again for every new row
+length) and makes the asset 2.5 GB. An iOS asset must not be loaded on a Mac.
+
+## Use it
+
+Swift, with the [`Kev`](https://github.com/john-rocky/coreai-model-zoo/tree/main/apps/Kev) package (macOS 27 / iOS 27; the system CoreAI framework,
+Accelerate and swift-transformers' tokenizer), on a download of the repository:
+
+```swift
+import Kev
+
+let bundle = URL(filePath: "Kev-0.8B-CoreAI/gpu-pipelined/kev_0_8b_decode_fp16_pf16")
+let kev = try await KevDecider(bundle: bundle)              // asset: nil = the .aimodel, specialized here (GPU, frequent reshapes)
+let response = try await kev.decide(requestJSON: requestData, shared: true)   // shared: the state's chunks run once
+print(PythonFormat.dumps(response, asciiOnly: false))
+// {"model": "kev_0_8b_decode_fp16_pf16", "answers": {"team": {"type": "choice", "choice": "billing", "confidence": …,
+//  "probabilities": {…}}, "urgent": {"type": "noul", "noul": …}}, "usage": {"input_tokens": …, "output_tokens": …}, "latency_ms": …}
+```
+
+The same from the Mac CLI (`swift build -c release --package-path apps/Kev` builds `kev`):
+
+```bash
+kev run --bundle Kev-0.8B-CoreAI/gpu-pipelined/kev_0_8b_decode_fp16_pf16 --asset jit \
+    --request req.json --shared --out resp.json
+```
+
+A request, in the SystemOne-compatible request shape:
+
+```json
+{"model": "kev-0.8b",
+ "state": "I was charged twice for order 1182. Please refund one of the charges.",
+ "questions": {
+   "team": {"type": "choice", "instructions": "Which team should handle this?",
+            "criteria": {"billing": "Charges and refunds", "shipping": "Deliveries", "returns": "Exchanges"}},
+   "urgent": {"type": "noul", "instructions": "Does this need a reply today?"}}}
+```
+
+Python: `conversion/kev/decide.py run --model kev-0.8b --bundle <folder> --aimodelc <asset> --request
+req.json [--shared] --out resp.json` is the gates' own read-out with `coreai.runtime`. It loads an AOT
+`.aimodelc` (compile one with the command above); the Python gates never used the Python runtime's JIT.
+
+## Reproduce
+
+Environment: the zoo overlay venv (coreai-core 1.0.0b2, coreai-torch 0.4.1, torch 2.9.0, transformers
+4.57.6), Xcode 27.0 RC. The author's code (the oracle and the merge) runs in its own venv built from the
+author's `uv.lock` at tag `kev-1.0` (torch 2.8.0, transformers 5.17.0, peft 0.21.0). The steps, in order,
+with every flag, are in [`conversion/kev/README.md`](https://github.com/john-rocky/coreai-model-zoo/blob/main/conversion/kev/README.md).
+
+```bash
+# the merged checkpoint, with the author's script (tag kev-1.0)
+(cd $ZOO_WORK_ROOT/_kev/kev-src && python scripts/merge_lora_checkpoint.py \
+    --lora jaredpalmer/kev-0.8b@788ddbdd65715bb03a56788c822f6c632c9a551d --out $ZOO_WORK_ROOT/_kev/merged/kev-0.8b-v1.0)
+# the decoder (--aot adds the h16c .aimodelc the Python gates load)
+python conversion/kev/export_decoder.py fp16 --prefill-chunk 16 --aot
+```
+
+Recipe: [`recipe.toml`](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/kev-0.8b/recipe.toml). Port notes: [`knowledge/kev-port.md`](https://github.com/john-rocky/coreai-model-zoo/blob/main/knowledge/kev-port.md).
+
+## Other formats
+
+On the Hub (2026-10-04), not run here:
+
+- Core ML: [`FluidInference/kev-0.8b-coreml`](https://huggingface.co/FluidInference/kev-0.8b-coreml), a
+  different runtime (Core ML packages for iOS 18 / macOS 15, fp16 on the GPU): a fused multifunction
+  package that packs a request's questions into one call, row packages, and the pointer head.
+- ONNX: [`midudev/kev-0.8b-ONNX`](https://huggingface.co/midudev/kev-0.8b-ONNX) (ONNX Runtime Web, int4
+  weights with the Gated DeltaNet projections and MLPs int8, the pointer head as `head.bin`).
+- GGUF: [`ggml-org/Kev-0.8B-GGUF`](https://huggingface.co/ggml-org/Kev-0.8B-GGUF) ("a decision model,
+  to be used via `/v1/systemone` API", per its card).
+- RKLLM: [`ShiWarai/kev-0.8b-rknn`](https://huggingface.co/ShiWarai/kev-0.8b-rknn) (Rockchip RK3588,
+  w8a8, the pointer head in NumPy on the CPU, rows up to 320 tokens).
+- Merged weights: [`ayan4m1/kev-0.8b-merged`](https://huggingface.co/ayan4m1/kev-0.8b-merged).
+- MLX: the author's repository serves Kev through MLX on Apple silicon.
+
+No other Core AI conversion of Kev was listed on the Hub on 2026-10-04.
+
+## License
+
+Apache-2.0: the adapter and the head (jaredpalmer/kev-0.8b) and the base (Qwen/Qwen3.5-0.8B-Base); the
+bundle inherits it, and the Hugging Face repository carries the base's `LICENSE`. The author's package
+runs only in the oracle and the merge, at gate time; it is not part of the bundle. The fixture file
+carries its own terms: its 144 SemIf authored144 items are MIT (github.com/TheoLeeCJ/SemIf at
+`ca3ba65f`), with their copyright and permission notice; the transfer-v4 records are references to the
+author's file (line and row hashes), not its text; of the 20 records written for the port, 11 are
+published and 9 are withheld (an invented name in each was found in use on the web), keeping their ids
+and numbers.
+
+## Limits
+
+From the [author's card](https://huggingface.co/jaredpalmer/kev-0.8b): English only; text generation,
+chat, tool-call routing and fully automated consequential decisions about people are out of scope; the
+temperature was fitted on the author's development rows (the card explains how to measure and refit it on
+one's own data). This port adds one limit: a row holds at most 4,080 tokens, while the author's server
+accepts states up to 65,536.

SHA256SUMS

@@ -0,0 +1,12 @@
+50cbab8a892c5f2993b8c7351a99182507472def3b1374558308605d99b86b32  LICENSE
+d21eecda6b62741ad3eadb39cf566e76194ef6e7e76a2c0d2248e3d125072773  README.md
+748acb2cda88454cb1ba69d745ba336f3fcb5486eac349e90960c8b8d8d3e854  adapter_config.json
+b90b86f35c8e6925ef74ee04d0e758f0a845c83a42089ad82bbaa948de9b4204  config.json
+12038b02ecf7ece3ffb008b22ae97988293e521a86e7aadc8036c9c700893a42  gpu-pipelined/kev_0_8b_decode_fp16_pf16/head/head.safetensors
+73d510708790422d3c84bfc915e311e536d527bc032f0a07394e76999d5c9d7c  gpu-pipelined/kev_0_8b_decode_fp16_pf16/head/kev_head.json
+5e53b0fa31411ab780585a1183e170407d3fcd5aac0b2053ca0ef1e37df5e87c  gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/main.hash
+4131d0284899787bab6cae6ca62a706886478b4e25c4d8cb971c5ba2ad72682d  gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/main.mlirb
+c751b845f3c70312dab24edf1084f98321b0b8c6e89fb0ea4a8263ab51e8185c  gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/metadata.json
+97b70e4393d549aada62381be4417a0ddb5ebf6491a5e824cb58ecb5f22b65b2  gpu-pipelined/kev_0_8b_decode_fp16_pf16/metadata.json
+fe000e3ed39ed12b8d2481d527d44f93c65d37e87645d2dcc80d1bf9d50d2927  gpu-pipelined/kev_0_8b_decode_fp16_pf16/tokenizer/tokenizer.json
+e611fbccc7c29ef3b1cafb1cb7ea548d189968632901d678fd62be68c47885de  gpu-pipelined/kev_0_8b_decode_fp16_pf16/tokenizer/tokenizer_config.json

adapter_config.json

@@ -0,0 +1,56 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen3.5-0.8B-Base",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "kasa_config": null,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.05,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.21.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "in_proj_b",
+    "in_proj_qkv",
+    "gate_proj",
+    "v_proj",
+    "o_proj",
+    "k_proj",
+    "up_proj",
+    "in_proj_z",
+    "in_proj_a",
+    "out_proj",
+    "down_proj",
+    "q_proj"
+  ],
+  "target_parameters": null,
+  "task_type": "FEATURE_EXTRACTION",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

config.json

@@ -0,0 +1,96 @@
+{
+    "architectures": [
+        "Qwen3_5ForConditionalGeneration"
+    ],
+    "image_token_id": 248056,
+    "model_type": "qwen3_5",
+    "text_config": {
+        "attention_bias": false,
+        "attention_dropout": 0.0,
+        "attn_output_gate": true,
+        "dtype": "bfloat16",
+        "eos_token_id": 248044,
+        "full_attention_interval": 4,
+        "head_dim": 256,
+        "hidden_act": "silu",
+        "hidden_size": 1024,
+        "initializer_range": 0.02,
+        "intermediate_size": 3584,
+        "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_conv_kernel_dim": 4,
+        "linear_key_head_dim": 128,
+        "linear_num_key_heads": 16,
+        "linear_num_value_heads": 16,
+        "linear_value_head_dim": 128,
+        "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": 8,
+        "num_hidden_layers": 24,
+        "num_key_value_heads": 2,
+        "rms_norm_eps": 1e-06,
+        "tie_word_embeddings": true,
+        "use_cache": true,
+        "vocab_size": 248320,
+        "mamba_ssm_dtype": "float32",
+        "rope_parameters": {
+            "mrope_interleaved": true,
+            "mrope_section": [
+                11,
+                11,
+                10
+            ],
+            "rope_type": "default",
+            "rope_theta": 10000000,
+            "partial_rotary_factor": 0.25
+        }
+    },
+    "tie_word_embeddings": true,
+    "transformers_version": "4.57.0.dev0",
+    "video_token_id": 248057,
+    "vision_config": {
+        "deepstack_visual_indexes": [],
+        "depth": 12,
+        "hidden_act": "gelu_pytorch_tanh",
+        "hidden_size": 768,
+        "in_channels": 3,
+        "initializer_range": 0.02,
+        "intermediate_size": 3072,
+        "model_type": "qwen3_5",
+        "num_heads": 12,
+        "num_position_embeddings": 2304,
+        "out_hidden_size": 1024,
+        "patch_size": 16,
+        "spatial_merge_size": 2,
+        "temporal_patch_size": 2
+    },
+    "vision_end_token_id": 248054,
+    "vision_start_token_id": 248053
+}

gpu-pipelined/kev_0_8b_decode_fp16_pf16/head/head.safetensors

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

gpu-pipelined/kev_0_8b_decode_fp16_pf16/head/kev_head.json

@@ -0,0 +1,67 @@
+{
+ "model": "kev-0.8b",
+ "hidden_size": 1024,
+ "head_dim": 256,
+ "scale": 0.0625,
+ "temperature": 2.3510958125672174,
+ "formula": "z_k = ((k.weight @ h_opt_k + k.bias) . (q.weight @ h_decide + q.bias)) * scale; p = softmax_k(z / temperature)",
+ "readout": {
+  "decide": "hidden state at the row's last token (<decide>)",
+  "option_k": "hidden state at option k's </opt> token",
+  "hidden": "the decoder's last_hidden_state (after the final RMSNorm), fp32"
+ },
+ "row": "one causal row per question: [state] + user_tokens(render(state)) + [q] + user_tokens(render(instructions)) + for each option ([opt] + user_tokens(option) + [opt_end]) + [decide]; positions 0..L-1; fresh state per row",
+ "user_tokens": "re.sub(r'<\\|([A-Za-z0-9_]+)\\|>', r'<¦\\1¦>', text), tokenized without special tokens",
+ "delimiters": {
+  "state": {
+   "token": "<|fim_prefix|>",
+   "id": 248060
+  },
+  "q": {
+   "token": "<|fim_middle|>",
+   "id": 248061
+  },
+  "opt": {
+   "token": "<|box_start|>",
+   "id": 248049
+  },
+  "opt_end": {
+   "token": "<|box_end|>",
+   "id": 248050
+  },
+  "decide": {
+   "token": "<|fim_suffix|>",
+   "id": 248062
+  }
+ },
+ "pad": {
+  "token": "<|endoftext|>",
+  "id": 248044
+ },
+ "base": {
+  "repo": "Qwen/Qwen3.5-0.8B-Base",
+  "revision": "dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68"
+ },
+ "adapter": {
+  "repo": "jaredpalmer/kev-0.8b",
+  "tag": "v1.0",
+  "revision": "788ddbdd65715bb03a56788c822f6c632c9a551d",
+  "resolved_commit": "bf75a6a8848ea6960ff2ed108d9ed44c2941174f",
+  "adapter_sha256": "9b908623acb162118575f4e7a94524f9c139c335be4bfb74d6cfceca01e1885a",
+  "head_pt_sha256": "f400bd12802b2b105ae45d6b03774a158a3db4fccff42413734ddca2e5c920b6"
+ },
+ "head_safetensors_sha256": "12038b02ecf7ece3ffb008b22ae97988293e521a86e7aadc8036c9c700893a42",
+ "temperature_fit": {
+  "rows": "runs/release/kev-08b-r15/development/rows.json",
+  "n": 1264,
+  "method": "min micro mean NLL over a 121-point log grid 0.25..4"
+ },
+ "record0_check": [
+  {
+   "record": "tv4_000",
+   "qid": "answer",
+   "bit_equal": true,
+   "max_abs_diff": 0.0
+  }
+ ]
+}

gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/main.hash

@@ -0,0 +1 @@
+A1�(H�x{�l�l�*ph�G�N%��˗[��rh-

gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/main.mlirb

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

gpu-pipelined/kev_0_8b_decode_fp16_pf16/kev_0_8b_decode_fp16_pf16.aimodel/metadata.json

@@ -0,0 +1,5 @@
+{
+  "assetVersion" : "2.0",
+  "producer" : "coreai-core 1.0.0b2",
+  "creationDate" : "20261003T073819Z"
+}

gpu-pipelined/kev_0_8b_decode_fp16_pf16/metadata.json

@@ -0,0 +1,279 @@
+{
+  "metadata_version": "0.2",
+  "kind": "decision-backbone",
+  "name": "kev_0_8b_decode_fp16_pf16",
+  "assets": {
+    "main": "kev_0_8b_decode_fp16_pf16.aimodel"
+  },
+  "language": {
+    "tokenizer": "Qwen/Qwen3.5-0.8B-Base",
+    "vocab_size": 248320,
+    "max_context_length": 4096,
+    "embedded_tokenizer": true,
+    "prefill_chunk": 16,
+    "static_inputs": [],
+    "output": "hidden [1, 16, 1024] fp16, every position",
+    "function_map": {
+      "main": [
+        "main"
+      ]
+    },
+    "tokenizer_revision": "dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68"
+  },
+  "source": {
+    "model_definition": "torch (coreai_models.models.macos.qwen3_5, conversion/kev/qwen3_5_kev_decoder.py)",
+    "adapter": {
+      "repo": "jaredpalmer/kev-0.8b",
+      "tag": "v1.0",
+      "tag_target": "788ddbdd65715bb03a56788c822f6c632c9a551d",
+      "resolved_commit": "bf75a6a8848ea6960ff2ed108d9ed44c2941174f",
+      "weights_identical_to": "9a45d25eb2ab761841196625383fa1dff0e56c1e (the card's weight revision; same LFS oids)",
+      "adapter_model_safetensors_sha256": "9b908623acb162118575f4e7a94524f9c139c335be4bfb74d6cfceca01e1885a",
+      "head_pt_sha256": "f400bd12802b2b105ae45d6b03774a158a3db4fccff42413734ddca2e5c920b6",
+      "license": "apache-2.0"
+    },
+    "base": {
+      "repo": "Qwen/Qwen3.5-0.8B-Base",
+      "revision": "dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68",
+      "safetensors_sha256": "c2b1e5a17d9c1e27685d92ed9b382911ebb99955ecd89052d1721241adfbab6c",
+      "license": "apache-2.0"
+    },
+    "merge": {
+      "tool": "scripts/merge_lora_checkpoint.py (https://github.com/jaredpalmer/kev tag kev-1.0, commit 6b719c3c3f367295f6ef336f4f751cf5ff970abc)",
+      "formula": "W + (B @ A) * alpha / r (alpha / r = 2.0) on every adapted weight, in fp32, written fp32 (12 target kinds, 186 adapted tensors); every other weight unchanged",
+      "weights_sha256": "ab6bd41853ef2a45d56923202e15c8c9c3dcedaec152b1fb8e529f1ec208415f",
+      "model_safetensors_sha256": "b5ebf92a9994a96d5c0c21b52f5eae23049c9e8b5a85fc625b4cea64076408db",
+      "tensors": 320,
+      "script": "scripts/merge_lora_checkpoint.py (github.com/jaredpalmer/kev tag kev-1.0)"
+    },
+    "hf_model_id": "jaredpalmer/kev-0.8b",
+    "hf_revision": "bf75a6a8848ea6960ff2ed108d9ed44c2941174f",
+    "tokenizer": {
+      "repo": "Qwen/Qwen3.5-0.8B-Base",
+      "revision": "dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68",
+      "files": {
+        "tokenizer.json": "fe000e3ed39ed12b8d2481d527d44f93c65d37e87645d2dcc80d1bf9d50d2927",
+        "tokenizer_config.json": "e611fbccc7c29ef3b1cafb1cb7ea548d189968632901d678fd62be68c47885de"
+      },
+      "shipped_in": "tokenizer/ (verbatim copies of the two files; embedded_tokenizer)"
+    },
+    "hf_revision_note": "the commit the Hub resolves the tag v1.0 to; the adapter and head.pt are the LFS objects named in source.adapter. The exporter read the merged checkpoint (source.merge) through a local cache id, which is not recorded here."
+  },
+  "compression": null,
+  "decision": {
+    "output": "hidden [1, S, 1024] per call: the final-norm hidden state at every position (no vocabulary head in the graph)",
+    "readout": "one row per question, fresh zero states per row; a row of T ids runs as ceil(T / 16) calls of 'main' (static S = 16): call k gets ids[16k : 16k + 16] with position_ids 0..16k+15; the last call is padded with <|endoftext|> (248044) and the hidden rows of the padded positions are discarded (causal: they cannot reach a real position). The hidden rows [1, 16, 1024] of every call, concatenated and cut to T, are the backbone's final-norm last_hidden_state [T, 1024] the head reads. A row fits when ceil(T / 16) * 16 <= 4095 (the position dim's upper bound; the KV sequence dim is allocated at 4096).",
+    "row": {
+      "source": "the author's kev.model.encode + rows_of (row form, https://github.com/jaredpalmer/kev tag kev-1.0); conversion/kev/oracle_kev.py records the oracle's rows",
+      "layout": "[<state>] + user_tokens(render(state)) + [<q>] + user_tokens(render(instructions)) + for each option ([<opt>] + user_tokens(option_text) + [</opt>]) + [<decide>]",
+      "delimiters": {
+        "state": {
+          "token": "<|fim_prefix|>",
+          "id": 248060
+        },
+        "q": {
+          "token": "<|fim_middle|>",
+          "id": 248061
+        },
+        "opt": {
+          "token": "<|box_start|>",
+          "id": 248049
+        },
+        "opt_end": {
+          "token": "<|box_end|>",
+          "id": 248050
+        },
+        "decide": {
+          "token": "<|fim_suffix|>",
+          "id": 248062
+        }
+      },
+      "pad": {
+        "token": "<|endoftext|>",
+        "id": 248044
+      },
+      "bos": null,
+      "positions": "0..L-1 (one causal row = the state ids then the question's branch ids)",
+      "user_tokens": "re.sub(r'<\\|([A-Za-z0-9_]+)\\|>', r'<¦\\1¦>', text), then tokenized without special tokens (user text can never produce a delimiter)",
+      "tokenizer": "tokenizer/ (the base model's pinned tokenizer.json + tokenizer_config.json)",
+      "readout_positions": {
+        "decide": "the row's last token (<decide>)",
+        "options": "each option's </opt> token, in option order"
+      },
+      "limits_author_serving": "state <= 65,536 tokens (the <state> token included), a row <= 73,728; this graph: one row <= the readout bound above"
+    },
+    "request": {
+      "source": "kev.api.to_record (SystemOne request -> internal record)",
+      "render": "None -> ''; str / int / float / bool -> str(v); array -> one line per item '- ' + render(item) (nested items indented by two spaces per level); object -> one line per key 'key: value', or 'key:' then the nested render indented by two spaces when the value is an object or an array",
+      "state": "render(state)",
+      "instructions": "render(instructions) (omitted -> '': the <q> token is followed by the options)",
+      "option_text": "name if description is None or '' else 'name: ' + render(description)",
+      "options": {
+        "noul": [
+          "option_text('no', criteria.false)",
+          "option_text('yes', criteria.true)"
+        ],
+        "choice": "option_text(name, description) for each criteria entry, in criteria order",
+        "score": "render(level) for each level, in order"
+      },
+      "question_keys": {
+        "noul": [
+          "false",
+          "true"
+        ],
+        "choice": "the criteria names, in order",
+        "score": "'0'..'n-1'"
+      },
+      "max_options": 255,
+      "validation": {
+        "source": "kev.api.SystemOneRequest (pydantic v2)",
+        "model": "string, default 'kev-latest'",
+        "state": "required, any JSON value (null allowed)",
+        "questions": "object of question id -> question, at least one",
+        "question": "type noul | choice | score; instructions: any JSON (optional); unknown fields ignored",
+        "noul": "criteria: object or null (optional); only 'true' and 'false' are read",
+        "choice": "criteria: object of 1..255 name -> description (any JSON; null or '' = the name alone)",
+        "score": "criteria: array of 1..255 levels (any JSON)",
+        "reject": "anything else (the author's server answers 422)"
+      }
+    },
+    "head": {
+      "files": [
+        "head/head.safetensors",
+        "head/kev_head.json"
+      ],
+      "formula": "z_k = ((k.weight @ h_opt_k + k.bias) . (q.weight @ h_decide + q.bias)) * 0.0625; p = softmax_k(z / temperature)",
+      "scale": 0.0625,
+      "temperature": "kev_head.json temperature (2.3510958125672174, the author's calibration in head.pt)",
+      "code": "kev.model.PointerHead.forward (q, k = nn.Linear(1024, 256)); weights from head.pt, fp32",
+      "dtype_of_record": "fp32 (the gate reads the graph's fp16 hidden through the fp32 head)",
+      "files_sha256": {
+        "head/head.safetensors": "12038b02ecf7ece3ffb008b22ae97988293e521a86e7aadc8036c9c700893a42",
+        "head/kev_head.json": "73d510708790422d3c84bfc915e311e536d527bc032f0a07394e76999d5c9d7c"
+      },
+      "temperature_value": 2.3510958125672174,
+      "hidden_size": 1024,
+      "head_dim": 256,
+      "host_arithmetic": "the round-5 reference host (conversion/kev/host.py) computes the head and the softmax in float64 from the fp16 hidden rows and the fp32 weights and rounds p to fp32 once; the author's PyTorch head is fp32 (on the same hidden rows they differ by fp32 rounding: max |dp| 3.0e-07 over the fixture and held-out rows)"
+    },
+    "softmax": "per question, fp32, over that question's options, after the temperature",
+    "response": {
+      "shape": "SystemOne-compatible: {model, answers: {question_id: answer}, usage: {input_tokens, output_tokens}, latency_ms} (kev.serve.Server._body)",
+      "noul": "{type: 'noul', noul: p(true)}",
+      "choice": "{type: 'choice', choice: the key of the first max p, confidence: (p_max - 1/K) / (1 - 1/K) (1 when K = 1), probabilities: {key: p}}",
+      "score": "{type: 'score', score: sum(i * p_i), legend: {key: render(level)}, probabilities: {key: p}, confidence: max(0, 1 - E|level - mode| / D), D = mean |i - (L-1)/2| over the L levels, mode = the first most likely level (1 when L = 1)}",
+      "normalize": "the confidences normalize p to sum 1 first (all zeros -> uniform)",
+      "rounding": "4 decimals (kev.api.round_prob)",
+      "usage": "input_tokens = the encoded request's tokens (the author's packed form: state once + every branch); output_tokens = tokens of json.dumps(answers) (kev.api.output_tokens)",
+      "sums": "every float sum in the confidences and the score is Python 3.12's sum(): left to right with Neumaier compensation (the author's runtime); p are the fp32 probabilities as doubles; round4 = Python round(x, 4)",
+      "model": "the author's server echoes the request's model (default 'kev-latest'); the round-5 reference host writes the bundle name",
+      "latency_ms": "the graph calls + the head (state allocations included; tokenizing and the answers not), 1 decimal",
+      "output_tokens_detail": "tokens of Python's json.dumps(answers) with its defaults (', ' and ': ' separators, ensure_ascii, floats as repr), plain tokenizer (special tokens matched, no user_tokens rewrite)"
+    },
+    "graph_context": {
+      "max_context_length": 4096,
+      "row_limit": "ceil(T / 16) * 16 <= 4095 (the position axis' upper bound = max_context_length - 1), so a row holds at most 4,080 tokens; the author's serving limits (state <= 65,536, row <= 73,728) are far above it"
+    },
+    "shared_prefix": "optional, exact: with Ls state tokens (<state> included) every question's row starts with the same k = Ls // 16 chunks; run them once, copy the four states per question (KV up to k*16 on its sequence axis, the rest zero; convState / recState as they are) and run each row's remaining tokens from position k*16 in the same chunk grid: the hidden rows are bit-equal to the direct run's (round 5, every fixture and held-out row of both models)"
+  },
+  "gate": {
+    "bar": {
+      "argmax": "every question whose oracle top-2 margin is above 0.02 (near-ties listed apart)",
+      "max_abs_dp": 0.02,
+      "mean_of_run_mean_abs_dp": 0.002,
+      "reset": "bit-equal in every process",
+      "finite": true
+    },
+    "oracle": "the author's fp32 checkpoint on the CPU (kev.model.admit + the row-form forward, threads 1)",
+    "fixture_434": {
+      "result": "PASS",
+      "rows": 434,
+      "argmax_non_near_tie": "420/420",
+      "argmax_near_tie": "12/14",
+      "max_abs_dp": 0.011679,
+      "mean_of_run_mean_abs_dp": 0.0009687,
+      "worst_row": {
+        "id": "semif_46b7029b9a704138b77a",
+        "q": 0,
+        "max_abs_dp": 0.011678963899612427
+      },
+      "reset_bit_equal_all_processes": true,
+      "finite": true,
+      "oracle_sha256": "1a72a45831eecc2af7ddfc68a86e9250f572d6bf9274362f96cc62bcb803cc6d",
+      "aimodelc_tree_sha256": "de1b6a1a12a0a7a3726bd043e9e5859b3ddea295e5c5dcec7fa87b33d25cef02",
+      "when": "2026-10-03T07:46:12+00:00",
+      "lane_file_sha256": "2c6a7846081de2e83bea6c6df792418aa8f2d5f846b96dadb7358fd0bf66219a",
+      "transcript": "coreai-model-zoo models/kev-0.8b/gate-kev-0.8b-readout-fp16_pf16.json"
+    },
+    "heldout_130": {
+      "result": "PASS",
+      "rows": 130,
+      "argmax_non_near_tie": "125/125",
+      "argmax_near_tie": "5/5",
+      "max_abs_dp": 0.005739,
+      "mean_of_run_mean_abs_dp": 0.0008054,
+      "worst_row": {
+        "id": "tv4h_11",
+        "q": 0,
+        "max_abs_dp": 0.005739271640777588
+      },
+      "reset_bit_equal_all_processes": true,
+      "finite": true,
+      "oracle_sha256": "f715653331a81bd0ff48d48d1f9d294b7b9b3343713a855fd0eed16dd1e505e6",
+      "aimodelc_tree_sha256": "de1b6a1a12a0a7a3726bd043e9e5859b3ddea295e5c5dcec7fa87b33d25cef02",
+      "when": "2026-10-03T10:00:46+00:00",
+      "lane_file_sha256": "0cbfed2c8e3a9c1cb58ecbb11de5668e7c5c2744e925be08980f589746bad603",
+      "transcript": "coreai-model-zoo models/kev-0.8b/gate-kev-0.8b-heldout.json"
+    },
+    "host_round5": {
+      "test_host": {
+        "sha256": "972b6ff76ad651d001de9971094b348f0fa03a92539319263904d4e5b4b22c12",
+        "oracle_venv_file": "results/host_test_oracle_venv.json",
+        "oracle_venv_sha256": "32d7ca3bbecd115df29d7a67a91ea2c5660188d52b9b5f0b56d45b7a7dd27e73",
+        "lane_file": "results/host_test.json"
+      },
+      "e2e_fixture": {
+        "sha256": "b8c3e6e3344c8899c22bf73cb8e9f51c525dbd387d3bd5b3e7245b91bc2f8851",
+        "rows": 434,
+        "hidden_bit_equal_gate": 434,
+        "torch_head_p_bit_equal_gate": 434,
+        "host_p_max_abs_dp_vs_gate": 2.980232238769531e-07,
+        "shared_p_bit_equal_direct": 434,
+        "host_bar_max_abs_dp": 0.011679,
+        "host_bar_mean": 0.0009687,
+        "lane_file": "results/e2e_kev-0.8b.json"
+      },
+      "e2e_heldout": {
+        "sha256": "9a04028c1c590ca17d3a27095c185412599f6fc8016361440a66a4b51dc588ad",
+        "rows": 130,
+        "hidden_bit_equal_gate": 130,
+        "torch_head_p_bit_equal_gate": 130,
+        "host_p_max_abs_dp_vs_gate": 2.384185791015625e-07,
+        "shared_p_bit_equal_direct": 130,
+        "host_bar_max_abs_dp": 0.005739,
+        "host_bar_mean": 0.0008054,
+        "lane_file": "results/e2e_kev-0.8b_heldout.json"
+      },
+      "transcript": "coreai-model-zoo models/kev-0.8b/gate-kev-0.8b-host.json"
+    },
+    "aimodelc": {
+      "name": "kev_0_8b_decode_fp16_pf16.h16c.aimodelc",
+      "tree_sha256": "de1b6a1a12a0a7a3726bd043e9e5859b3ddea295e5c5dcec7fa87b33d25cef02"
+    },
+    "fixture": "coreai-model-zoo models/kev-0.8b/fixtures-kev-0.8b.json"
+  },
+  "compilation": {
+    "date": "2026-10-03T07:38:20.417082+00:00",
+    "targets": []
+  },
+  "metadata_of_record": {
+    "exported_metadata_json_sha256": "01251e9649bd73421a67ee0942b047d52ea81ae12f3b3c310958bd9e9bd139f0",
+    "edits": [
+      "language.tokenizer = the base repo id (was the local id of the merged checkpoint) + tokenizer_revision",
+      "source.hf_model_id / hf_revision = the Kev checkpoint (was the local HF-cache id of the merged weights)",
+      "decision.request / response / graph_context / shared_prefix and gate: added in round 5 from the reference host (metadata.candidate.json)",
+      "gate transcripts named by their zoo files"
+    ],
+    "written": "2026-10-04 (round 9)"
+  }
+}

gpu-pipelined/kev_0_8b_decode_fp16_pf16/tokenizer/tokenizer.json

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

gpu-pipelined/kev_0_8b_decode_fp16_pf16/tokenizer/tokenizer_config.json

@@ -0,0 +1,305 @@
+{
+    "add_prefix_space": false,
+    "added_tokens_decoder": {
+        "248044": {
+            "content": "<|endoftext|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248045": {
+            "content": "<|im_start|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248046": {
+            "content": "<|im_end|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248047": {
+            "content": "<|object_ref_start|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248048": {
+            "content": "<|object_ref_end|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248049": {
+            "content": "<|box_start|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248050": {
+            "content": "<|box_end|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248051": {
+            "content": "<|quad_start|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248052": {
+            "content": "<|quad_end|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248053": {
+            "content": "<|vision_start|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248054": {
+            "content": "<|vision_end|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248055": {
+            "content": "<|vision_pad|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248056": {
+            "content": "<|image_pad|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248057": {
+            "content": "<|video_pad|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248058": {
+            "content": "<tool_call>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248059": {
+            "content": "</tool_call>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248060": {
+            "content": "<|fim_prefix|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248061": {
+            "content": "<|fim_middle|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248062": {
+            "content": "<|fim_suffix|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248063": {
+            "content": "<|fim_pad|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248064": {
+            "content": "<|repo_name|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248065": {
+            "content": "<|file_sep|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248066": {
+            "content": "<tool_response>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248067": {
+            "content": "</tool_response>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248068": {
+            "content": "<think>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248069": {
+            "content": "</think>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": false
+        },
+        "248070": {
+            "content": "<|audio_start|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248071": {
+            "content": "<|audio_end|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248072": {
+            "content": "<tts_pad>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248073": {
+            "content": "<tts_text_bos>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248074": {
+            "content": "<tts_text_eod>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248075": {
+            "content": "<tts_text_bos_single>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        },
+        "248076": {
+            "content": "<|audio_pad|>",
+            "lstrip": false,
+            "normalized": false,
+            "rstrip": false,
+            "single_word": false,
+            "special": true
+        }
+    },
+    "additional_special_tokens": [
+        "<|im_start|>",
+        "<|im_end|>",
+        "<|object_ref_start|>",
+        "<|object_ref_end|>",
+        "<|box_start|>",
+        "<|box_end|>",
+        "<|quad_start|>",
+        "<|quad_end|>",
+        "<|vision_start|>",
+        "<|vision_end|>",
+        "<|vision_pad|>",
+        "<|image_pad|>",
+        "<|video_pad|>"
+    ],
+    "bos_token": null,
+    "chat_template": "{%- set image_count = namespace(value=0) %}\n{%- set video_count = namespace(value=0) %}\n{%- macro render_content(content, do_vision_count, is_system_content=false) %}\n    {%- if content is string %}\n        {{- content }}\n    {%- elif content is iterable and content is not mapping %}\n        {%- for item in content %}\n            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}\n                {%- if is_system_content %}\n                    {{- raise_exception('System message cannot contain images.') }}\n                {%- endif %}\n                {%- if do_vision_count %}\n                    {%- set image_count.value = image_count.value + 1 %}\n                {%- endif %}\n                {%- if add_vision_id %}\n                    {{- 'Picture ' ~ image_count.value ~ ': ' }}\n                {%- endif %}\n                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}\n            {%- elif 'video' in item or item.type == 'video' %}\n                {%- if is_system_content %}\n                    {{- raise_exception('System message cannot contain videos.') }}\n                {%- endif %}\n                {%- if do_vision_count %}\n                    {%- set video_count.value = video_count.value + 1 %}\n                {%- endif %}\n                {%- if add_vision_id %}\n                    {{- 'Video ' ~ video_count.value ~ ': ' }}\n                {%- endif %}\n                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}\n            {%- elif 'text' in item %}\n                {{- item.text }}\n            {%- else %}\n                {{- raise_exception('Unexpected item type in content.') }}\n            {%- endif %}\n        {%- endfor %}\n    {%- elif content is none or content is undefined %}\n        {{- '' }}\n    {%- else %}\n        {{- raise_exception('Unexpected content type.') }}\n    {%- endif %}\n{%- endmacro %}\n{%- if not messages %}\n    {{- raise_exception('No messages provided.') }}\n{%- endif %}\n{%- if tools and tools is iterable and tools is not mapping %}\n    {{- '<|im_start|>system\\n' }}\n    {{- \"# Tools\\n\\nYou have access to the following functions:\\n\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\" }}\n    {{- '\\n\\nIf you choose to call a function ONLY reply in the following format with NO suffix:\\n\\n<tool_call>\\n<function=example_function_name>\\n<parameter=example_parameter_1>\\nvalue_1\\n</parameter>\\n<parameter=example_parameter_2>\\nThis is the value for the second parameter\\nthat can span\\nmultiple lines\\n</parameter>\\n</function>\\n</tool_call>\\n\\n<IMPORTANT>\\nReminder:\\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\\n- Required parameters MUST be specified\\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\\n</IMPORTANT>' }}\n    {%- if messages[0].role == 'system' %}\n        {%- set content = render_content(messages[0].content, false, true)|trim %}\n        {%- if content %}\n            {{- '\\n\\n' + content }}\n        {%- endif %}\n    {%- endif %}\n    {{- '<|im_end|>\\n' }}\n{%- else %}\n    {%- if messages[0].role == 'system' %}\n        {%- set content = render_content(messages[0].content, false, true)|trim %}\n        {{- '<|im_start|>system\\n' + content + '<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}\n{%- for message in messages[::-1] %}\n    {%- set index = (messages|length - 1) - loop.index0 %}\n    {%- if ns.multi_step_tool and message.role == \"user\" %}\n        {%- set content = render_content(message.content, false)|trim %}\n        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}\n            {%- set ns.multi_step_tool = false %}\n            {%- set ns.last_query_index = index %}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if ns.multi_step_tool %}\n    {{- raise_exception('No user query found in messages.') }}\n{%- endif %}\n{%- for message in messages %}\n    {%- set content = render_content(message.content, true)|trim %}\n    {%- if message.role == \"system\" %}\n        {%- if not loop.first %}\n            {{- raise_exception('System message must be at the beginning.') }}\n        {%- endif %}\n    {%- elif message.role == \"user\" %}\n        {{- '<|im_start|>' + message.role + '\\n' + content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {%- set reasoning_content = '' %}\n        {%- if message.reasoning_content is string %}\n            {%- set reasoning_content = message.reasoning_content %}\n        {%- else %}\n            {%- if '</think>' in content %}\n                {%- set reasoning_content = content.split('</think>')[0].rstrip('\\n').split('<think>')[-1].lstrip('\\n') %}\n                {%- set content = content.split('</think>')[-1].lstrip('\\n') %}\n            {%- endif %}\n        {%- endif %}\n        {%- set reasoning_content = reasoning_content|trim %}\n        {%- if loop.index0 > ns.last_query_index %}\n            {{- '<|im_start|>' + message.role + '\\n<think>\\n' + reasoning_content + '\\n</think>\\n\\n' + content }}\n        {%- else %}\n            {{- '<|im_start|>' + message.role + '\\n' + content }}\n        {%- endif %}\n        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}\n            {%- for tool_call in message.tool_calls %}\n                {%- if tool_call.function is defined %}\n                    {%- set tool_call = tool_call.function %}\n                {%- endif %}\n                {%- if loop.first %}\n                    {%- if content|trim %}\n                        {{- '\\n\\n<tool_call>\\n<function=' + tool_call.name + '>\\n' }}\n                    {%- else %}\n                        {{- '<tool_call>\\n<function=' + tool_call.name + '>\\n' }}\n                    {%- endif %}\n                {%- else %}\n                    {{- '\\n<tool_call>\\n<function=' + tool_call.name + '>\\n' }}\n                {%- endif %}\n                {%- if tool_call.arguments is defined %}\n                    {%- for args_name, args_value in tool_call.arguments|items %}\n                        {{- '<parameter=' + args_name + '>\\n' }}\n                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}\n                        {{- args_value }}\n                        {{- '\\n</parameter>\\n' }}\n                    {%- endfor %}\n                {%- endif %}\n                {{- '</function>\\n</tool_call>' }}\n            {%- endfor %}\n        {%- endif %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if loop.previtem and loop.previtem.role != \"tool\" %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- content }}\n        {{- '\\n</tool_response>' }}\n        {%- if not loop.last and loop.nextitem.role != \"tool\" %}\n            {{- '<|im_end|>\\n' }}\n        {%- elif loop.last %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- else %}\n        {{- raise_exception('Unexpected message role.') }}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n    {%- if enable_thinking is defined and enable_thinking is true %}\n        {{- '<think>\\n' }}\n    {%- else %}\n        {{- '<think>\\n\\n</think>\\n\\n' }}\n    {%- endif %}\n{%- endif %}",
+    "clean_up_tokenization_spaces": false,
+    "eos_token": "<|endoftext|>",
+    "errors": "replace",
+    "model_max_length": 262144,
+    "pad_token": "<|endoftext|>",
+    "split_special_tokens": false,
+    "tokenizer_class": "Qwen2Tokenizer",
+    "unk_token": null,
+    "add_bos_token": false,
+    "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+",
+    "extra_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|>"
+    }
+}