Add files using upload-large-folder tool

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 [yyyy] [name of copyright owner]
+
+   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,139 @@
+---
+license: apache-2.0
+base_model: google/gemma-4-12B-it
+base_model_relation: quantized
+pipeline_tag: text-generation
+tags:
+- tenstorrent
+- blackhole
+- p150
+- ttnn
+- tt-metal
+- bfp8
+- gemma4
+- speculative-decoding
+- long-context
+- custom-runtime
+---
+
+# Gemma 4 12B IT — TT-native all-BFP8, single P150, 262K context, speculative decoding
+
+A hardware-specific, text-only checkpoint and custom runtime derived from [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it), revision `707f0a3b8a3c7ad586ed01e27eafbad8a27dd0f7`, for one Tenstorrent Blackhole P150. The drafter for speculative decoding is derived from [google/gemma-4-12B-it-assistant](https://huggingface.co/google/gemma-4-12B-it-assistant), revision `46d4c6f13f0ac0ad827b915669b8df9b81c64c51`.
+
+This is a community experimental release by **Lottolabs**, not an official Google or Tenstorrent release. It is not GGUF, AWQ, GPTQ, bitsandbytes, or an ordinary Transformers checkpoint. `transformers.from_pretrained()`, llama.cpp and hosted Inference Providers cannot load it. It needs the bundled runtime.
+
+## Quantization
+
+All-BFP8: every text matrix (attention, MLP, LM head) is stored as TTNN `bfloat8_b`. The embedding is BF16; 1-D tensors (norms, layer scalars) are lossless BF16 in `small.safetensors`. See [`gemma-4-12B-it/precision_plan.json`](gemma-4-12B-it/precision_plan.json) and [`gemma-4-12B-it/native_manifest.json`](gemma-4-12B-it/native_manifest.json).
+
+`tensors/tensor_cache_bf16/*.tensorbin` holds the exact TTNN host tensors that the runtime uploads to device DRAM. The directory name comes from the runtime's tensor-cache writer. The files are not a regenerable cache: they are the checkpoint. Every file is hashed in the manifest, and the loader refuses to start if any file is missing or changed. The drafter (`gemma-4-12B-it-assistant/`) stores its tensors the same way. Its recorded dtype is `bfp8-lm4`: BFP8 weights and a BFP4 drafter LM head.
+
+The loader requires two proofs, both bound to the manifests:
+
+- [`gemma-4-12B-it/equivalence.json`](gemma-4-12B-it/equivalence.json): the full logits of the native reload are bit-exact to quantizing the original weights at load time, over 4,093 teacher-forced tokens (`exact_logits_equal: true`).
+- [`gemma-4-12B-it-assistant/spec_equivalence.json`](gemma-4-12B-it-assistant/spec_equivalence.json): greedy speculative decoding with draft length 5 produced token streams identical to non-speculative greedy decoding on the same proven runtime (`streams_identical: true`, 3,130 tokens compared).
+
+## Quality versus the original BF16 model
+
+Teacher-forced comparison against the original model run in BF16 on CPU ([`evidence/quality/quant_table.json`](evidence/quality/quant_table.json)). dPPL is the perplexity change relative to BF16, top-1 is argmax agreement with BF16, and KL is the mean KL divergence on the short-prompt set:
+
+| Plan | Weight read | chat dPPL / top-1 | code dPPL / top-1 | 16K book dPPL / top-1 | KL | GSM8K-50 |
+|---|---:|---:|---:|---:|---:|---:|
+| **all-BFP8 (this release)** | 12.7 GB | **−0.3% / 97.1%** | **+1.0% / 98.3%** | **+1.6% / 97.2%** | **0.009** | **50/50** |
+| BFP8 + BFP4 LM head | 12.2 GB | +0.6% / 95.5% | +2.0% / 97.0% | +2.6% / 96.1% | 0.019 | 49/50 |
+| MLP in BFP4 | 8.4 GB | +5.2% / 87.1% | +3.9% / 90.8% | +9.9% / 87.7% | 0.175 | 49/50 |
+| all-BFP4 | 7.2 GB | +7.2% / 82.7% | +8.3% / 87.4% | +19.2% / 80.1% | 0.296 | — |
+
+**Why BFP8 and not BFP4:** with the MLP in BFP4, perplexity rises about 5% and top-1 agreement falls to about 87%. All-BFP4 is worse still. BFP8 stays within about 1–2% of BF16 perplexity.
+
+The shipped runtime adds batched speculative verification and a fused GELU×up kernel. It passed a decode-path quality gate against the exact (unfused) build ([`evidence/quality/runtime-gate-dtf-score.json`](evidence/quality/runtime-gate-dtf-score.json)): argmax agreement with the exact build was 98.8% on chat, 98.8% on code and 98.4% on long-book text. The NLL change versus the exact build was +0.0017 ± 0.0012 on chat, −0.0004 ± 0.0030 on code and −0.0061 ± 0.0096 on long-book. The two proofs above were recorded with this shipped runtime configuration.
+
+## Performance
+
+These numbers were measured over HTTP on one P150 with greedy decoding, 512-token outputs, chat prompts, one user and speculative decoding on ([`evidence/http-p3c/`](evidence/http-p3c/)):
+
+| Prompt tokens | 128 | 2K | 8K | 32K | 131K | 262K (261,632) |
+|---|---:|---:|---:|---:|---:|---:|
+| Decode tok/s | 50.6 | 49.3 | 46.9 | 45.1 | 29.7 | 21.8 |
+| TTFT (s) | 0.09 | 0.64 | 3.2 | 17.0 | 124 | 395 |
+
+With the LocalMaxxing official prompt (a local run of the official protocol, not submitted), the server reached **49.9 output tok/s** with a **95 ms** TTFT (median of 5, 256 output tokens; [`evidence/localmaxxing/speed-test.json`](evidence/localmaxxing/speed-test.json)).
+
+## Serving correctness
+
+- **HTTP matches the direct runtime token for token.** All 28 of 28 checks passed ([`evidence/http-p3c/exact.json`](evidence/http-p3c/exact.json)). They cover chat and completion outputs on 10 prompts, request isolation, sampled requests followed by greedy ones, cancellation mid-prefill and mid-decode, and rejection of image input. The 512-token outputs at 32K and 261,632 prompt tokens were also identical to the direct runtime ([`evidence/http-p3c/tput_vs_direct.json`](evidence/http-p3c/tput_vs_direct.json)).
+- **Long context works to the native limit.** Passkeys at the beginning, middle and end of the prompt were retrieved at 32,768, 131,072 and 262,016 prompt tokens. A request totalling 262,145 tokens was rejected with HTTP 400 before generation started ([`evidence/http-p3c/long.json`](evidence/http-p3c/long.json)).
+- **The public package was verified end to end.** It was downloaded fresh and served on a P150 ([`evidence/public-download-verification.json`](evidence/public-download-verification.json), [`evidence/public-serving-smoke.json`](evidence/public-serving-smoke.json)).
+
+## Download and serve
+
+Prerequisites:
+
+- Linux with a supported P150 driver and hugepage mounts at `/dev/hugepages` and `/dev/hugepages-1G`.
+- Docker and Python 3.11 or newer.
+- Exclusive ownership of one P150.
+- Disk space for about 21.3 GB of downloads: a 14.7 GB checkpoint, a 1.2 GB drafter and a 5.4 GB compressed runtime archive. You also need room for the loaded image and a writable kernel cache.
+
+Download the standard-library launcher:
+
+```bash
+curl --fail --location --output launch.py \
+  https://huggingface.co/Lottolabs/gemma-4-12B-it-TT-BFP8-P150/resolve/main/launch.py
+
+python3 launch.py \
+  --cache-root "$HOME/.cache/gemma4-12b-tt-native" \
+  --device-ownership-confirmed
+```
+
+The launcher does the following before it serves anything:
+
+1. Resolves the requested Hugging Face revision to an immutable commit.
+2. Downloads only the serving package (the checkpoint, drafter, server script and runtime archive) and verifies every byte against `runtime-release.json`.
+3. Checks that the published file sets match both native manifests.
+4. Loads the checksum-pinned runtime archive into Docker and checks the resulting image ID.
+
+`serve_native.py` then verifies the manifests, file hashes and both proofs again, checks the image ID once more, and starts vLLM. Inside the container, the loader repeats the checks against the image's runtime identity.
+
+The original BF16 weights are not needed. The API is OpenAI-compatible, binds to `127.0.0.1:8000`, and serves the model name `google/gemma-4-12B-it`. The first launch compiles kernels into the kernel cache, so it takes longer than later launches.
+
+Useful modes:
+
+```bash
+# Download and verify without Docker or a device
+python3 launch.py --cache-root /large-disk/gemma4-12b --download-only
+
+# Print the exact serving command without starting it
+python3 launch.py --cache-root /large-disk/gemma4-12b --print-command
+
+# Non-speculative serving (no drafter)
+python3 launch.py --cache-root /large-disk/gemma4-12b --speculation off --device-ownership-confirmed
+```
+
+Save the immutable revision that the launcher prints, and pass it with `--revision` to reproduce the same setup exactly.
+
+```bash
+curl http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{
+  "model": "google/gemma-4-12B-it", "temperature": 0, "max_tokens": 256,
+  "messages": [{"role": "user", "content": "Explain database transactions in three sentences."}]}'
+```
+
+## Limits
+
+- One user at a time (`max_num_seqs 1`), one P150 (MeshShape 1x1), no multi-device support.
+- Text only. Requests with images are rejected.
+- Context up to 262,144 tokens in total. Sliding-window layers keep their KV cache as 18,432-token rings. Prefill runs in 16,384-token chunks, and prefix caching is off.
+- Only greedy requests (`temperature: 0`) decode speculatively (drafter K=5, exact per-row verification). Requests with other sampling settings are served but decode one token per step with vLLM's host sampler, so they are slower.
+- Long prompts have a long time to first token: about 17 s at 32K and about 6.6 min at 262K.
+
+## Integrity and provenance
+
+- [`runtime-release.json`](runtime-release.json): the serving inventory the launcher downloads, the runtime archive checksum, the expected Docker image ID and the upstream revisions.
+- [`release-manifest.json`](release-manifest.json): the complete repository inventory with size and sha256 for every file.
+- [`SHA256SUMS`](SHA256SUMS): file checksums.
+- [`reproduction.json`](reproduction.json): source, runtime, serving and evidence contract.
+- [`runtime/`](runtime/): source of the runtime image layers, recorded in [`runtime/source.json`](runtime/source.json). It contains the Gemma 4 TT model tree (`runtime/gemma4/`, git commit `ce67960382fffed8550b38717cedf574e821da06`, byte-identical to the tree in the image), the vLLM/TT-plugin serving overlay, the TTNN matmul overlay, the Dockerfile chain and the build script. This is provenance: serving uses the checksum-pinned `runtime-image.tar.gz`.
+- [`native_checkpoint.py`](native_checkpoint.py) and [`provenance/build_native_checkpoint.py`](provenance/build_native_checkpoint.py): the manifest, proof and verification tool, and the checkpoint builder.
+
+## License and attribution
+
+Derived from [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it) and [google/gemma-4-12B-it-assistant](https://huggingface.co/google/gemma-4-12B-it-assistant). Apache-2.0; see [`LICENSE`](LICENSE). The runtime includes tt-metal and vLLM, which keep their upstream notices; see [`runtime/licenses/`](runtime/licenses/).

evidence/http-p3c/exact.json

@@ -0,0 +1,185 @@
+{
+ "checks": [
+  {
+   "name": "health",
+   "ok": true
+  },
+  {
+   "name": "chat_exact_story",
+   "ok": true,
+   "n": 250,
+   "ref_n": 250,
+   "finish": "stop",
+   "events": 104,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_explain",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 109,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_code",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 102,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_math",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 66,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_logic",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 96,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_code-lru",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 86,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_code-c",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 74,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_code-sql",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 76,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_long-summary",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 108,
+   "first_divergence": null
+  },
+  {
+   "name": "chat_exact_long-code",
+   "ok": true,
+   "n": 320,
+   "ref_n": 320,
+   "finish": "length",
+   "events": 108,
+   "first_divergence": null
+  },
+  {
+   "name": "completion_exact_story",
+   "ok": true,
+   "n": 250
+  },
+  {
+   "name": "completion_exact_explain",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_code",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_math",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_logic",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_code-lru",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_code-c",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_code-sql",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_long-summary",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "completion_exact_long-code",
+   "ok": true,
+   "n": 320
+  },
+  {
+   "name": "isolation_ABA",
+   "ok": true,
+   "n": 128
+  },
+  {
+   "name": "sampled_request",
+   "ok": true,
+   "n": 64
+  },
+  {
+   "name": "greedy_after_sampled",
+   "ok": true
+  },
+  {
+   "name": "cancel_mid_decode",
+   "ok": true,
+   "cancelled_after": 42,
+   "next_request_s": 3.266689165000571
+  },
+  {
+   "name": "cancel_mid_prefill",
+   "ok": true,
+   "cancelled_after_s": 8.170486249990063,
+   "next_request_s": 11.995801645010943
+  },
+  {
+   "name": "image_rejected",
+   "ok": true,
+   "status": 400,
+   "body": "{\"error\":{\"message\":\"/model is not a multimodal model\",\"type\":\"BadRequestError\",\"param\":null,\"code\":400}}"
+  },
+  {
+   "name": "health_end",
+   "ok": true
+  }
+ ],
+ "exact_seconds": 110.89393173001008
+}

evidence/http-p3c/long.json

@@ -0,0 +1,231 @@
+[
+  {
+    "name": "configuration",
+    "url": "http://127.0.0.1:8000",
+    "model": "google/gemma-4-12B-it",
+    "contexts": [
+      32768,
+      131072,
+      262016
+    ],
+    "tokens": 128,
+    "native_max_len": 262144,
+    "request_timeout_seconds": 3600,
+    "cases": [
+      {
+        "input_tokens": 32768,
+        "output_tokens": 128
+      },
+      {
+        "input_tokens": 131072,
+        "output_tokens": 128
+      },
+      {
+        "input_tokens": 262016,
+        "output_tokens": 128
+      }
+    ],
+    "begin_key_token_region": [
+      0,
+      43
+    ],
+    "end_key_suffix_tokens": 65,
+    "timing_basis": "Client first/last non-empty SSE text arrival; MTP may emit multiple tokens per event"
+  },
+  {
+    "name": "short_before",
+    "input_tokens": 25,
+    "requested_output_tokens": 32,
+    "requested_total_tokens": 57,
+    "ttft_seconds": 0.09288164801546372,
+    "decode_wall_seconds": 0.054585256992140785,
+    "seconds": 0.20159582499763928,
+    "decode_tokens_per_second": 128.2397553062334,
+    "finish_reason": "stop",
+    "sse_done": true,
+    "response": {
+      "text": "The capital of France is Paris.",
+      "usage": {
+        "prompt_tokens": 25,
+        "total_tokens": 33,
+        "completion_tokens": 8
+      }
+    },
+    "expected_keys": {
+      "known_answer": "Paris"
+    },
+    "retrieved_keys": {
+      "known_answer": true
+    },
+    "accuracy": true
+  },
+  {
+    "name": "layout_32768",
+    "input_tokens": 32768,
+    "begin_key_offset": 35,
+    "middle_key_offset": 16021,
+    "end_key_offset": 32707
+  },
+  {
+    "name": "stream_32768_128",
+    "input_tokens": 32768,
+    "requested_output_tokens": 128,
+    "requested_total_tokens": 32896,
+    "ttft_seconds": 16.92090609599836,
+    "decode_wall_seconds": 0.47541975299827754,
+    "seconds": 17.39640123900608,
+    "decode_tokens_per_second": 71.51574957829567,
+    "finish_reason": "stop",
+    "sse_done": true,
+    "response": {
+      "text": "CEDAR-7419-QUARTZ\nHARBOR-5096-VIOLET\nORBIT-2863-MARBLE",
+      "usage": {
+        "prompt_tokens": 32768,
+        "total_tokens": 32803,
+        "completion_tokens": 35
+      }
+    },
+    "expected_keys": {
+      "begin": "CEDAR-7419-QUARTZ",
+      "middle": "HARBOR-5096-VIOLET",
+      "end": "ORBIT-2863-MARBLE"
+    },
+    "retrieved_keys": {
+      "begin": true,
+      "middle": true,
+      "end": true
+    },
+    "accuracy": true
+  },
+  {
+    "name": "layout_131072",
+    "input_tokens": 131072,
+    "begin_key_offset": 35,
+    "middle_key_offset": 65832,
+    "end_key_offset": 131011
+  },
+  {
+    "name": "stream_131072_128",
+    "input_tokens": 131072,
+    "requested_output_tokens": 128,
+    "requested_total_tokens": 131200,
+    "ttft_seconds": 123.78426550599397,
+    "decode_wall_seconds": 0.6346804780187085,
+    "seconds": 124.41902046301402,
+    "decode_tokens_per_second": 53.57026279764946,
+    "finish_reason": "stop",
+    "sse_done": true,
+    "response": {
+      "text": "CEDAR-7419-QUARTZ\nHARBOR-5096-VIOLET\nORBIT-2863-MARBLE",
+      "usage": {
+        "prompt_tokens": 131072,
+        "total_tokens": 131107,
+        "completion_tokens": 35
+      }
+    },
+    "expected_keys": {
+      "begin": "CEDAR-7419-QUARTZ",
+      "middle": "HARBOR-5096-VIOLET",
+      "end": "ORBIT-2863-MARBLE"
+    },
+    "retrieved_keys": {
+      "begin": true,
+      "middle": true,
+      "end": true
+    },
+    "accuracy": true
+  },
+  {
+    "name": "layout_262016",
+    "input_tokens": 262016,
+    "begin_key_offset": 35,
+    "middle_key_offset": 130632,
+    "end_key_offset": 261955
+  },
+  {
+    "name": "stream_262016_128",
+    "input_tokens": 262016,
+    "requested_output_tokens": 128,
+    "requested_total_tokens": 262144,
+    "ttft_seconds": 394.87144183402415,
+    "decode_wall_seconds": 0.9865862159931567,
+    "seconds": 395.98883561600815,
+    "decode_tokens_per_second": 34.462269438635495,
+    "finish_reason": "stop",
+    "sse_done": true,
+    "response": {
+      "text": "CEDAR-7419-QUARTZ\nHARBOR-5096-VIOLET\nORBIT-2863-MARBLE",
+      "usage": {
+        "prompt_tokens": 262016,
+        "total_tokens": 262051,
+        "completion_tokens": 35
+      }
+    },
+    "expected_keys": {
+      "begin": "CEDAR-7419-QUARTZ",
+      "middle": "HARBOR-5096-VIOLET",
+      "end": "ORBIT-2863-MARBLE"
+    },
+    "retrieved_keys": {
+      "begin": true,
+      "middle": true,
+      "end": true
+    },
+    "accuracy": true
+  },
+  {
+    "name": "native_overflow_rejection",
+    "input_tokens": 262016,
+    "requested_output_tokens": 129,
+    "requested_total_tokens": 262145,
+    "native_max_len": 262144,
+    "status": 400,
+    "seconds": 0.014193854993209243,
+    "rejected_before_generation": true,
+    "response": {
+      "error": {
+        "message": "You passed 262016 input tokens and requested 129 output tokens. However, the model's context length is only 262144 tokens, resulting in a maximum input length of 262015 tokens. Please reduce the length of the input prompt. (parameter=input_tokens, value=262016)",
+        "type": "BadRequestError",
+        "param": "input_tokens",
+        "code": 400
+      }
+    }
+  },
+  {
+    "name": "mtp_acceptance",
+    "accepted_tokens_before": 10883.0,
+    "accepted_tokens_after": 10964.0,
+    "accepted_tokens_delta": 81.0
+  },
+  {
+    "name": "short_after",
+    "input_tokens": 25,
+    "requested_output_tokens": 32,
+    "requested_total_tokens": 57,
+    "ttft_seconds": 0.0965569649997633,
+    "decode_wall_seconds": 0.05454791599186137,
+    "seconds": 0.20529347998672165,
+    "decode_tokens_per_second": 128.32754235825269,
+    "finish_reason": "stop",
+    "sse_done": true,
+    "response": {
+      "text": "The capital of France is Paris.",
+      "usage": {
+        "prompt_tokens": 25,
+        "total_tokens": 33,
+        "completion_tokens": 8
+      }
+    },
+    "expected_keys": {
+      "known_answer": "Paris"
+    },
+    "retrieved_keys": {
+      "known_answer": true
+    },
+    "accuracy": true
+  },
+  {
+    "name": "state_isolation",
+    "exact_text_match": true
+  }
+]

evidence/http-p3c/tput-128/requests-128-c1.json

@@ -0,0 +1,34 @@
+[
+  {
+    "index": 0,
+    "start_seconds": 1.4730001566931605e-05,
+    "end_seconds": 10.182251366000855,
+    "ttft_seconds": 0.09181618399452418,
+    "latency_seconds": 10.182236635999288,
+    "decode_tokens_per_second": 50.64247901615711,
+    "text_sha256": "63c80dca9b9d4cea4f271acb863cf1aa059fb2b80e4fdb79796fb57ba73337e3",
+    "usage": {
+      "prompt_tokens": 128,
+      "total_tokens": 640,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "# Understanding Database Transactions: The Foundation of Data Integrity\n\nIn the world of software engineering and data management, the reliability of information is paramount. Whether you are transferring money between bank accounts, booking a flight, or updating an inventory system, the underlying database must ensure that data remains accurate, consistent, and reliable even in the face of system crashes, power failures, or concurrent access by thousands of users. This reliability is achieved through a mechanism known as a **Database Transaction**.\n\nA transaction is a logical unit of work that consists of one or more database operations (such as Insert, Update, Delete, or Select). To be considered valid, a transaction must be treated as a single, indivisible entity: either every operation within the transaction succeeds, or none of them do.\n\nTo define the behavior of these transactions, the database community relies on a set of four fundamental properties known as **ACID**.\n\n---\n\n### The ACID Properties\n\nTo understand transactions in detail, we must break down the ACID acronym, which serves as the gold standard for database reliability.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single \"atom.\" If a transaction contains five different SQL statements, and the fourth one fails (due to a constraint violation, a lost connection, or a crash), the database must \"roll back\" the first three statements. The database is returned to the exact state it was in before the transaction started.\n\n*   **Example:** Imagine a bank transfer where User A sends $100 to User B. This involves two steps:\n    1. Subtract $100 from User A\u2019s balance.\n    2. Add $100 to User B\u2019s balance.\n    If the system crashes after step 1 but before step 2, User A loses money, but User B never receives it. Atomicity prevents this by ensuring that if step 2 fails, step 1 is undone automatically.\n\n#### 2. Consistency (Preserving Rules)\nConsistency ensures that a transaction brings the database from one valid state to another valid state, maintaining all predefined rules, including constraints, foreign keys, and triggers. A transaction cannot leave the database in a \"broken\" state where data violates the business logic.\n\n*   **Example:** Suppose a database has a rule that a \"Product Price\" cannot be a negative number. If a transaction attempts to update a price to -$50, the database will detect this violation of the"
+  },
+  {
+    "index": 1,
+    "start_seconds": 10.182313314988278,
+    "end_seconds": 20.363098062982317,
+    "ttft_seconds": 0.09173648501746356,
+    "latency_seconds": 10.18078474799404,
+    "decode_tokens_per_second": 50.64928144502961,
+    "text_sha256": "63c80dca9b9d4cea4f271acb863cf1aa059fb2b80e4fdb79796fb57ba73337e3",
+    "usage": {
+      "prompt_tokens": 128,
+      "total_tokens": 640,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "# Understanding Database Transactions: The Foundation of Data Integrity\n\nIn the world of software engineering and data management, the reliability of information is paramount. Whether you are transferring money between bank accounts, booking a flight, or updating an inventory system, the underlying database must ensure that data remains accurate, consistent, and reliable even in the face of system crashes, power failures, or concurrent access by thousands of users. This reliability is achieved through a mechanism known as a **Database Transaction**.\n\nA transaction is a logical unit of work that consists of one or more database operations (such as Insert, Update, Delete, or Select). To be considered valid, a transaction must be treated as a single, indivisible entity: either every operation within the transaction succeeds, or none of them do.\n\nTo define the behavior of these transactions, the database community relies on a set of four fundamental properties known as **ACID**.\n\n---\n\n### The ACID Properties\n\nTo understand transactions in detail, we must break down the ACID acronym, which serves as the gold standard for database reliability.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single \"atom.\" If a transaction contains five different SQL statements, and the fourth one fails (due to a constraint violation, a lost connection, or a crash), the database must \"roll back\" the first three statements. The database is returned to the exact state it was in before the transaction started.\n\n*   **Example:** Imagine a bank transfer where User A sends $100 to User B. This involves two steps:\n    1. Subtract $100 from User A\u2019s balance.\n    2. Add $100 to User B\u2019s balance.\n    If the system crashes after step 1 but before step 2, User A loses money, but User B never receives it. Atomicity prevents this by ensuring that if step 2 fails, step 1 is undone automatically.\n\n#### 2. Consistency (Preserving Rules)\nConsistency ensures that a transaction brings the database from one valid state to another valid state, maintaining all predefined rules, including constraints, foreign keys, and triggers. A transaction cannot leave the database in a \"broken\" state where data violates the business logic.\n\n*   **Example:** Suppose a database has a rule that a \"Product Price\" cannot be a negative number. If a transaction attempts to update a price to -$50, the database will detect this violation of the"
+  }
+]

evidence/http-p3c/tput-128/summary.json

@@ -0,0 +1,24 @@
+{
+  "model": "google/gemma-4-12B-it",
+  "output_tokens": 512,
+  "method": "Closed loop; synchronized initial clients; max(min_requests,2*concurrency) requests; nearest-rank percentiles; aggregate includes prefill and queue drain",
+  "cases": [
+    {
+      "input_tokens": 128,
+      "concurrency": 1,
+      "requests": 2,
+      "successes": 2,
+      "errors": 0,
+      "wall_seconds": 20.36308333298075,
+      "matching_single_request_outputs": 2,
+      "aggregate_output_tokens_per_second": 50.28707996993237,
+      "requests_per_second": 0.09821695306627416,
+      "ttft_seconds_p50": 0.09173648501746356,
+      "ttft_seconds_p95": 0.09181618399452418,
+      "latency_seconds_p50": 10.18078474799404,
+      "latency_seconds_p95": 10.182236635999288,
+      "decode_tokens_per_second_p50": 50.64247901615711,
+      "decode_tokens_per_second_p95": 50.64928144502961
+    }
+  ]
+}

evidence/http-p3c/tput-128/warmup-128.json

@@ -0,0 +1,16 @@
+{
+  "index": -1,
+  "start_seconds": 7.700000423938036e-07,
+  "end_seconds": 10.291406103991903,
+  "ttft_seconds": 0.09075412299716845,
+  "latency_seconds": 10.291405333991861,
+  "decode_tokens_per_second": 50.09516148932038,
+  "text_sha256": "63c80dca9b9d4cea4f271acb863cf1aa059fb2b80e4fdb79796fb57ba73337e3",
+  "usage": {
+    "prompt_tokens": 128,
+    "total_tokens": 640,
+    "completion_tokens": 512
+  },
+  "error": null,
+  "text": "# Understanding Database Transactions: The Foundation of Data Integrity\n\nIn the world of software engineering and data management, the reliability of information is paramount. Whether you are transferring money between bank accounts, booking a flight, or updating an inventory system, the underlying database must ensure that data remains accurate, consistent, and reliable even in the face of system crashes, power failures, or concurrent access by thousands of users. This reliability is achieved through a mechanism known as a **Database Transaction**.\n\nA transaction is a logical unit of work that consists of one or more database operations (such as Insert, Update, Delete, or Select). To be considered valid, a transaction must be treated as a single, indivisible entity: either every operation within the transaction succeeds, or none of them do.\n\nTo define the behavior of these transactions, the database community relies on a set of four fundamental properties known as **ACID**.\n\n---\n\n### The ACID Properties\n\nTo understand transactions in detail, we must break down the ACID acronym, which serves as the gold standard for database reliability.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single \"atom.\" If a transaction contains five different SQL statements, and the fourth one fails (due to a constraint violation, a lost connection, or a crash), the database must \"roll back\" the first three statements. The database is returned to the exact state it was in before the transaction started.\n\n*   **Example:** Imagine a bank transfer where User A sends $100 to User B. This involves two steps:\n    1. Subtract $100 from User A\u2019s balance.\n    2. Add $100 to User B\u2019s balance.\n    If the system crashes after step 1 but before step 2, User A loses money, but User B never receives it. Atomicity prevents this by ensuring that if step 2 fails, step 1 is undone automatically.\n\n#### 2. Consistency (Preserving Rules)\nConsistency ensures that a transaction brings the database from one valid state to another valid state, maintaining all predefined rules, including constraints, foreign keys, and triggers. A transaction cannot leave the database in a \"broken\" state where data violates the business logic.\n\n*   **Example:** Suppose a database has a rule that a \"Product Price\" cannot be a negative number. If a transaction attempts to update a price to -$50, the database will detect this violation of the"
+}

evidence/http-p3c/tput-131072/requests-131072-c1.json

@@ -0,0 +1,34 @@
+[
+  {
+    "index": 0,
+    "start_seconds": 3.7209014408290386e-05,
+    "end_seconds": 140.95895639900118,
+    "ttft_seconds": 123.78377083898522,
+    "latency_seconds": 140.95891918998677,
+    "decode_tokens_per_second": 29.752375978499117,
+    "text_sha256": "3c3c3d343fcdd17e18b186d6c873612d183159c8add64b188f1e1594b957a4f6",
+    "usage": {
+      "prompt_tokens": 131072,
+      "total_tokens": 131584,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is the fundamental unit of work. It is a sequence of one or more operations performed as a single logical unit. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and the database is updated, or if even one operation fails, the entire transaction is undone, leaving the database in its original state.\n\nTo understand why this is critical, imagine an ATM withdrawal. You want to take out $100. The system must perform two distinct actions:\n1.  Subtract $100 from your account balance.\n2.  Dispense $100 in cash.\n\nIf the system subtracts the money but the machine fails to dispense the cash, you lose your money. If the machine dispenses the cash but the system fails to update your balance, the bank loses money. A transaction ensures that these two steps are bound together so that one cannot happen without the other.\n\n---\n\n### The ACID Properties: The Gold Standard of Transactions\n\nFor a database to be considered reliable, it must adhere to the **ACID** properties. These four principles ensure that data remains accurate and consistent, even in the event of system crashes, power failures, or concurrent access by thousands of users.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity guarantees that a transaction is treated as a single, indivisible unit. If a transaction consists of five different SQL queries, and the fourth query fails due to a constraint violation or a lost connection, the first three queries are \"rolled back.\" The database reverts to the state it was in before the transaction started.\n\n*   **Example:** In a hotel booking system, a transaction involves:\n    *   Checking room availability.\n    *   Creating a reservation record.\n    *   Charging the customer's credit card.\n    *   Sending a confirmation email.\n    If the credit card charge fails, the reservation record must be deleted, and the room must be marked as available again. Atomicity prevents \"ghost\" reservations where a room is held but no payment was received.\n\n#### 2. Consistency (Rules of the Game)\nConsistency ensures that a transaction brings the database from one valid state to another. Every database has predefined rules (constraints), such as \"account balances cannot be negative\" or \"every order must have a valid Customer ID.\" A transaction must follow these rules. If"
+  },
+  {
+    "index": 1,
+    "start_seconds": 140.95899165899027,
+    "end_seconds": 281.9431601790129,
+    "ttft_seconds": 123.80123381401063,
+    "latency_seconds": 140.98416852002265,
+    "decode_tokens_per_second": 29.738932975990465,
+    "text_sha256": "3c3c3d343fcdd17e18b186d6c873612d183159c8add64b188f1e1594b957a4f6",
+    "usage": {
+      "prompt_tokens": 131072,
+      "total_tokens": 131584,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is the fundamental unit of work. It is a sequence of one or more operations performed as a single logical unit. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and the database is updated, or if even one operation fails, the entire transaction is undone, leaving the database in its original state.\n\nTo understand why this is critical, imagine an ATM withdrawal. You want to take out $100. The system must perform two distinct actions:\n1.  Subtract $100 from your account balance.\n2.  Dispense $100 in cash.\n\nIf the system subtracts the money but the machine fails to dispense the cash, you lose your money. If the machine dispenses the cash but the system fails to update your balance, the bank loses money. A transaction ensures that these two steps are bound together so that one cannot happen without the other.\n\n---\n\n### The ACID Properties: The Gold Standard of Transactions\n\nFor a database to be considered reliable, it must adhere to the **ACID** properties. These four principles ensure that data remains accurate and consistent, even in the event of system crashes, power failures, or concurrent access by thousands of users.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity guarantees that a transaction is treated as a single, indivisible unit. If a transaction consists of five different SQL queries, and the fourth query fails due to a constraint violation or a lost connection, the first three queries are \"rolled back.\" The database reverts to the state it was in before the transaction started.\n\n*   **Example:** In a hotel booking system, a transaction involves:\n    *   Checking room availability.\n    *   Creating a reservation record.\n    *   Charging the customer's credit card.\n    *   Sending a confirmation email.\n    If the credit card charge fails, the reservation record must be deleted, and the room must be marked as available again. Atomicity prevents \"ghost\" reservations where a room is held but no payment was received.\n\n#### 2. Consistency (Rules of the Game)\nConsistency ensures that a transaction brings the database from one valid state to another. Every database has predefined rules (constraints), such as \"account balances cannot be negative\" or \"every order must have a valid Customer ID.\" A transaction must follow these rules. If"
+  }
+]

evidence/http-p3c/tput-131072/summary.json

@@ -0,0 +1,24 @@
+{
+  "model": "google/gemma-4-12B-it",
+  "output_tokens": 512,
+  "method": "Closed loop; synchronized initial clients; max(min_requests,2*concurrency) requests; nearest-rank percentiles; aggregate includes prefill and queue drain",
+  "cases": [
+    {
+      "input_tokens": 131072,
+      "concurrency": 1,
+      "requests": 2,
+      "successes": 2,
+      "errors": 0,
+      "wall_seconds": 281.9431229699985,
+      "matching_single_request_outputs": 2,
+      "aggregate_output_tokens_per_second": 3.6319382051711315,
+      "requests_per_second": 0.007093629306974866,
+      "ttft_seconds_p50": 123.78377083898522,
+      "ttft_seconds_p95": 123.80123381401063,
+      "latency_seconds_p50": 140.95891918998677,
+      "latency_seconds_p95": 140.98416852002265,
+      "decode_tokens_per_second_p50": 29.738932975990465,
+      "decode_tokens_per_second_p95": 29.752375978499117
+    }
+  ]
+}

evidence/http-p3c/tput-131072/warmup-131072.json

@@ -0,0 +1,16 @@
+{
+  "index": -1,
+  "start_seconds": 1.1700030881911516e-06,
+  "end_seconds": 143.83761601298465,
+  "ttft_seconds": 126.47853563597891,
+  "latency_seconds": 143.83761484298157,
+  "decode_tokens_per_second": 29.43717637800883,
+  "text_sha256": "3c3c3d343fcdd17e18b186d6c873612d183159c8add64b188f1e1594b957a4f6",
+  "usage": {
+    "prompt_tokens": 131072,
+    "total_tokens": 131584,
+    "completion_tokens": 512
+  },
+  "error": null,
+  "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is the fundamental unit of work. It is a sequence of one or more operations performed as a single logical unit. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and the database is updated, or if even one operation fails, the entire transaction is undone, leaving the database in its original state.\n\nTo understand why this is critical, imagine an ATM withdrawal. You want to take out $100. The system must perform two distinct actions:\n1.  Subtract $100 from your account balance.\n2.  Dispense $100 in cash.\n\nIf the system subtracts the money but the machine fails to dispense the cash, you lose your money. If the machine dispenses the cash but the system fails to update your balance, the bank loses money. A transaction ensures that these two steps are bound together so that one cannot happen without the other.\n\n---\n\n### The ACID Properties: The Gold Standard of Transactions\n\nFor a database to be considered reliable, it must adhere to the **ACID** properties. These four principles ensure that data remains accurate and consistent, even in the event of system crashes, power failures, or concurrent access by thousands of users.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity guarantees that a transaction is treated as a single, indivisible unit. If a transaction consists of five different SQL queries, and the fourth query fails due to a constraint violation or a lost connection, the first three queries are \"rolled back.\" The database reverts to the state it was in before the transaction started.\n\n*   **Example:** In a hotel booking system, a transaction involves:\n    *   Checking room availability.\n    *   Creating a reservation record.\n    *   Charging the customer's credit card.\n    *   Sending a confirmation email.\n    If the credit card charge fails, the reservation record must be deleted, and the room must be marked as available again. Atomicity prevents \"ghost\" reservations where a room is held but no payment was received.\n\n#### 2. Consistency (Rules of the Game)\nConsistency ensures that a transaction brings the database from one valid state to another. Every database has predefined rules (constraints), such as \"account balances cannot be negative\" or \"every order must have a valid Customer ID.\" A transaction must follow these rules. If"
+}

evidence/http-p3c/tput-2048/requests-2048-c1.json

@@ -0,0 +1,34 @@
+[
+  {
+    "index": 0,
+    "start_seconds": 1.6479985788464546e-05,
+    "end_seconds": 11.016043118987,
+    "ttft_seconds": 0.6452015560062137,
+    "latency_seconds": 11.016026639001211,
+    "decode_tokens_per_second": 49.27316326165929,
+    "text_sha256": "271e3153ec0cf27b50e15284295499fdc4e38a58b0e7034a928379447e546564",
+    "usage": {
+      "prompt_tokens": 2048,
+      "total_tokens": 2560,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations (such as inserting, updating, deleting, or querying data) that are treated as a single, indivisible unit of work. \n\nThe core philosophy behind transactions is \"all or nothing.\" If every operation within the transaction succeeds, the entire transaction is \"committed,\" and the changes become permanent. If even a single operation fails, the entire transaction is \"rolled back,\" and the database is returned to the state it was in before the transaction began.\n\nTo understand how transactions work, we must explore the **ACID properties**, the lifecycle of a transaction, concurrency control, and real-world applications.\n\n---\n\n### 1. The ACID Properties\nThe reliability of a database system is measured by its adherence to the ACID properties. These four principles ensure that even in the event of system crashes, power failures, or concurrent access by thousands of users, the data remains accurate.\n\n#### A - Atomicity\nAtomicity ensures that a transaction is treated as a single \"atom\"\u2014it cannot be broken into smaller pieces. If a transaction involves five different SQL statements, and the fourth one fails due to a constraint violation or a lost connection, the first three must be undone.\n*   **Example:** Imagine a bank transfer where \\$100 is moved from Account A to Account B. This involves two steps: subtracting \\$100 from A and adding \\$100 to B. If the system crashes after subtracting from A but before adding to B, the money would effectively vanish. Atomicity prevents this by ensuring that if the addition to B fails, the subtraction from A is reversed.\n\n#### C - Consistency\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules, including constraints, cascades, and triggers. A transaction must not violate the \"rules\" of the database.\n*   **Example:** If a database has a rule that a bank balance cannot fall below zero, and a transaction attempts to withdraw \\$500 from an account containing only \\$200, the database will reject the transaction to maintain consistency.\n\n#### I - Isolation\nIn a multi-user environment, many transactions happen simultaneously. Isolation ensures that the concurrent execution of transactions results in a system state that is the same as if the transactions were executed sequentially ("
+  },
+  {
+    "index": 1,
+    "start_seconds": 11.016083038994111,
+    "end_seconds": 22.032156578003196,
+    "ttft_seconds": 0.6449967880034819,
+    "latency_seconds": 11.016073539009085,
+    "decode_tokens_per_second": 49.27197280097986,
+    "text_sha256": "271e3153ec0cf27b50e15284295499fdc4e38a58b0e7034a928379447e546564",
+    "usage": {
+      "prompt_tokens": 2048,
+      "total_tokens": 2560,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations (such as inserting, updating, deleting, or querying data) that are treated as a single, indivisible unit of work. \n\nThe core philosophy behind transactions is \"all or nothing.\" If every operation within the transaction succeeds, the entire transaction is \"committed,\" and the changes become permanent. If even a single operation fails, the entire transaction is \"rolled back,\" and the database is returned to the state it was in before the transaction began.\n\nTo understand how transactions work, we must explore the **ACID properties**, the lifecycle of a transaction, concurrency control, and real-world applications.\n\n---\n\n### 1. The ACID Properties\nThe reliability of a database system is measured by its adherence to the ACID properties. These four principles ensure that even in the event of system crashes, power failures, or concurrent access by thousands of users, the data remains accurate.\n\n#### A - Atomicity\nAtomicity ensures that a transaction is treated as a single \"atom\"\u2014it cannot be broken into smaller pieces. If a transaction involves five different SQL statements, and the fourth one fails due to a constraint violation or a lost connection, the first three must be undone.\n*   **Example:** Imagine a bank transfer where \\$100 is moved from Account A to Account B. This involves two steps: subtracting \\$100 from A and adding \\$100 to B. If the system crashes after subtracting from A but before adding to B, the money would effectively vanish. Atomicity prevents this by ensuring that if the addition to B fails, the subtraction from A is reversed.\n\n#### C - Consistency\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules, including constraints, cascades, and triggers. A transaction must not violate the \"rules\" of the database.\n*   **Example:** If a database has a rule that a bank balance cannot fall below zero, and a transaction attempts to withdraw \\$500 from an account containing only \\$200, the database will reject the transaction to maintain consistency.\n\n#### I - Isolation\nIn a multi-user environment, many transactions happen simultaneously. Isolation ensures that the concurrent execution of transactions results in a system state that is the same as if the transactions were executed sequentially ("
+  }
+]

evidence/http-p3c/tput-2048/summary.json

@@ -0,0 +1,24 @@
+{
+  "model": "google/gemma-4-12B-it",
+  "output_tokens": 512,
+  "method": "Closed loop; synchronized initial clients; max(min_requests,2*concurrency) requests; nearest-rank percentiles; aggregate includes prefill and queue drain",
+  "cases": [
+    {
+      "input_tokens": 2048,
+      "concurrency": 1,
+      "requests": 2,
+      "successes": 2,
+      "errors": 0,
+      "wall_seconds": 22.032140098017408,
+      "matching_single_request_outputs": 2,
+      "aggregate_output_tokens_per_second": 46.477554855969075,
+      "requests_per_second": 0.0907764743280646,
+      "ttft_seconds_p50": 0.6449967880034819,
+      "ttft_seconds_p95": 0.6452015560062137,
+      "latency_seconds_p50": 11.016026639001211,
+      "latency_seconds_p95": 11.016073539009085,
+      "decode_tokens_per_second_p50": 49.27197280097986,
+      "decode_tokens_per_second_p95": 49.27316326165929
+    }
+  ]
+}

evidence/http-p3c/tput-2048/warmup-2048.json

@@ -0,0 +1,16 @@
+{
+  "index": -1,
+  "start_seconds": 8.799834176898003e-07,
+  "end_seconds": 11.195358822995331,
+  "ttft_seconds": 0.6444937330088578,
+  "latency_seconds": 11.195357943011913,
+  "decode_tokens_per_second": 48.43237123768412,
+  "text_sha256": "271e3153ec0cf27b50e15284295499fdc4e38a58b0e7034a928379447e546564",
+  "usage": {
+    "prompt_tokens": 2048,
+    "total_tokens": 2560,
+    "completion_tokens": 512
+  },
+  "error": null,
+  "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations (such as inserting, updating, deleting, or querying data) that are treated as a single, indivisible unit of work. \n\nThe core philosophy behind transactions is \"all or nothing.\" If every operation within the transaction succeeds, the entire transaction is \"committed,\" and the changes become permanent. If even a single operation fails, the entire transaction is \"rolled back,\" and the database is returned to the state it was in before the transaction began.\n\nTo understand how transactions work, we must explore the **ACID properties**, the lifecycle of a transaction, concurrency control, and real-world applications.\n\n---\n\n### 1. The ACID Properties\nThe reliability of a database system is measured by its adherence to the ACID properties. These four principles ensure that even in the event of system crashes, power failures, or concurrent access by thousands of users, the data remains accurate.\n\n#### A - Atomicity\nAtomicity ensures that a transaction is treated as a single \"atom\"\u2014it cannot be broken into smaller pieces. If a transaction involves five different SQL statements, and the fourth one fails due to a constraint violation or a lost connection, the first three must be undone.\n*   **Example:** Imagine a bank transfer where \\$100 is moved from Account A to Account B. This involves two steps: subtracting \\$100 from A and adding \\$100 to B. If the system crashes after subtracting from A but before adding to B, the money would effectively vanish. Atomicity prevents this by ensuring that if the addition to B fails, the subtraction from A is reversed.\n\n#### C - Consistency\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules, including constraints, cascades, and triggers. A transaction must not violate the \"rules\" of the database.\n*   **Example:** If a database has a rule that a bank balance cannot fall below zero, and a transaction attempts to withdraw \\$500 from an account containing only \\$200, the database will reject the transaction to maintain consistency.\n\n#### I - Isolation\nIn a multi-user environment, many transactions happen simultaneously. Isolation ensures that the concurrent execution of transactions results in a system state that is the same as if the transactions were executed sequentially ("
+}

evidence/http-p3c/tput-261632/requests-261632-c1.json

@@ -0,0 +1,34 @@
+[
+  {
+    "index": 0,
+    "start_seconds": 4.0059007005766034e-05,
+    "end_seconds": 418.1412177470047,
+    "ttft_seconds": 394.7243818969873,
+    "latency_seconds": 418.1411776879977,
+    "decode_tokens_per_second": 21.822016190474002,
+    "text_sha256": "5f68fd62ed476b10bc5c9080ee9d9b8e764722ada2fe1e961fdfb8404c7444b4",
+    "usage": {
+      "prompt_tokens": 261632,
+      "total_tokens": 262144,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **transaction** is the fundamental unit of work. Whether you are transferring money between bank accounts, booking a flight, or updating an inventory system, these actions are rarely single, isolated events. They are usually composed of multiple steps that must all succeed together or fail together.\n\nTo ensure that a database remains reliable and accurate despite system crashes, concurrent access by multiple users, or network failures, database systems adhere to a set of principles known as **ACID properties**.\n\n---\n\n### 1. The Core Concept: What is a Transaction?\nA transaction is a sequence of operations performed as a single logical unit. The defining characteristic of a transaction is that it is **indivisible**. If any part of the sequence fails, the entire transaction must be undone, returning the database to the state it was in before the transaction started.\n\n**Example: The Bank Transfer**\nImagine you want to transfer \\$100 from Account A to Account B. This involves two distinct steps:\n1.  **Debit:** Subtract \\$100 from Account A.\n2.  **Credit:** Add \\$100 to Account B.\n\nIf the system crashes *after* step 1 but *before* step 2, Account A loses money, but Account B never receives it. The money effectively vanishes. A database transaction ensures that either both steps happen, or neither happens.\n\n---\n\n### 2. The ACID Properties\nTo guarantee reliability, every database management system (DBMS) must follow the ACID model:\n\n#### A - Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single \"atom.\" It cannot be broken down into smaller parts. If a transaction contains five SQL statements and the fourth one fails, the first three are \"rolled back\" (undone), and the fifth is never executed.\n*   **Mechanism:** This is usually managed by a **Transaction Log**. The database records every change before it happens. If a failure occurs, it uses the log to reverse the partial changes.\n\n#### C - Consistency (\"Valid State to Valid State\")\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules (constraints). These rules include data types, unique keys, and foreign key relationships.\n*   **Example:** If a database rule states that an account balance cannot drop below zero, and a transaction tries to withdraw \\$500"
+  },
+  {
+    "index": 1,
+    "start_seconds": 418.1412568560045,
+    "end_seconds": 836.2879148600041,
+    "ttft_seconds": 394.70167387797846,
+    "latency_seconds": 418.1466580039996,
+    "decode_tokens_per_second": 21.795770483933808,
+    "text_sha256": "5f68fd62ed476b10bc5c9080ee9d9b8e764722ada2fe1e961fdfb8404c7444b4",
+    "usage": {
+      "prompt_tokens": 261632,
+      "total_tokens": 262144,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **transaction** is the fundamental unit of work. Whether you are transferring money between bank accounts, booking a flight, or updating an inventory system, these actions are rarely single, isolated events. They are usually composed of multiple steps that must all succeed together or fail together.\n\nTo ensure that a database remains reliable and accurate despite system crashes, concurrent access by multiple users, or network failures, database systems adhere to a set of principles known as **ACID properties**.\n\n---\n\n### 1. The Core Concept: What is a Transaction?\nA transaction is a sequence of operations performed as a single logical unit. The defining characteristic of a transaction is that it is **indivisible**. If any part of the sequence fails, the entire transaction must be undone, returning the database to the state it was in before the transaction started.\n\n**Example: The Bank Transfer**\nImagine you want to transfer \\$100 from Account A to Account B. This involves two distinct steps:\n1.  **Debit:** Subtract \\$100 from Account A.\n2.  **Credit:** Add \\$100 to Account B.\n\nIf the system crashes *after* step 1 but *before* step 2, Account A loses money, but Account B never receives it. The money effectively vanishes. A database transaction ensures that either both steps happen, or neither happens.\n\n---\n\n### 2. The ACID Properties\nTo guarantee reliability, every database management system (DBMS) must follow the ACID model:\n\n#### A - Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single \"atom.\" It cannot be broken down into smaller parts. If a transaction contains five SQL statements and the fourth one fails, the first three are \"rolled back\" (undone), and the fifth is never executed.\n*   **Mechanism:** This is usually managed by a **Transaction Log**. The database records every change before it happens. If a failure occurs, it uses the log to reverse the partial changes.\n\n#### C - Consistency (\"Valid State to Valid State\")\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules (constraints). These rules include data types, unique keys, and foreign key relationships.\n*   **Example:** If a database rule states that an account balance cannot drop below zero, and a transaction tries to withdraw \\$500"
+  }
+]

evidence/http-p3c/tput-261632/summary.json

@@ -0,0 +1,24 @@
+{
+  "model": "google/gemma-4-12B-it",
+  "output_tokens": 512,
+  "method": "Closed loop; synchronized initial clients; max(min_requests,2*concurrency) requests; nearest-rank percentiles; aggregate includes prefill and queue drain",
+  "cases": [
+    {
+      "input_tokens": 261632,
+      "concurrency": 1,
+      "requests": 2,
+      "successes": 2,
+      "errors": 0,
+      "wall_seconds": 836.2878748009971,
+      "matching_single_request_outputs": 2,
+      "aggregate_output_tokens_per_second": 1.2244587430418872,
+      "requests_per_second": 0.002391520982503686,
+      "ttft_seconds_p50": 394.70167387797846,
+      "ttft_seconds_p95": 394.7243818969873,
+      "latency_seconds_p50": 418.1411776879977,
+      "latency_seconds_p95": 418.1466580039996,
+      "decode_tokens_per_second_p50": 21.795770483933808,
+      "decode_tokens_per_second_p95": 21.822016190474002
+    }
+  ]
+}

evidence/http-p3c/tput-261632/warmup-261632.json

@@ -0,0 +1,16 @@
+{
+  "index": -1,
+  "start_seconds": 8.700008038431406e-07,
+  "end_seconds": 419.97353838098934,
+  "ttft_seconds": 396.40250135198585,
+  "latency_seconds": 419.97353751098854,
+  "decode_tokens_per_second": 21.679220519427187,
+  "text_sha256": "5f68fd62ed476b10bc5c9080ee9d9b8e764722ada2fe1e961fdfb8404c7444b4",
+  "usage": {
+    "prompt_tokens": 261632,
+    "total_tokens": 262144,
+    "completion_tokens": 512
+  },
+  "error": null,
+  "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **transaction** is the fundamental unit of work. Whether you are transferring money between bank accounts, booking a flight, or updating an inventory system, these actions are rarely single, isolated events. They are usually composed of multiple steps that must all succeed together or fail together.\n\nTo ensure that a database remains reliable and accurate despite system crashes, concurrent access by multiple users, or network failures, database systems adhere to a set of principles known as **ACID properties**.\n\n---\n\n### 1. The Core Concept: What is a Transaction?\nA transaction is a sequence of operations performed as a single logical unit. The defining characteristic of a transaction is that it is **indivisible**. If any part of the sequence fails, the entire transaction must be undone, returning the database to the state it was in before the transaction started.\n\n**Example: The Bank Transfer**\nImagine you want to transfer \\$100 from Account A to Account B. This involves two distinct steps:\n1.  **Debit:** Subtract \\$100 from Account A.\n2.  **Credit:** Add \\$100 to Account B.\n\nIf the system crashes *after* step 1 but *before* step 2, Account A loses money, but Account B never receives it. The money effectively vanishes. A database transaction ensures that either both steps happen, or neither happens.\n\n---\n\n### 2. The ACID Properties\nTo guarantee reliability, every database management system (DBMS) must follow the ACID model:\n\n#### A - Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single \"atom.\" It cannot be broken down into smaller parts. If a transaction contains five SQL statements and the fourth one fails, the first three are \"rolled back\" (undone), and the fifth is never executed.\n*   **Mechanism:** This is usually managed by a **Transaction Log**. The database records every change before it happens. If a failure occurs, it uses the log to reverse the partial changes.\n\n#### C - Consistency (\"Valid State to Valid State\")\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules (constraints). These rules include data types, unique keys, and foreign key relationships.\n*   **Example:** If a database rule states that an account balance cannot drop below zero, and a transaction tries to withdraw \\$500"
+}

evidence/http-p3c/tput-32768/requests-32768-c1.json

@@ -0,0 +1,34 @@
+[
+  {
+    "index": 0,
+    "start_seconds": 1.7960002878680825e-05,
+    "end_seconds": 28.333977759990375,
+    "ttft_seconds": 16.9979730900086,
+    "latency_seconds": 28.333959799987497,
+    "decode_tokens_per_second": 45.07796922419997,
+    "text_sha256": "776449f071272b7ffcaa722fc9113043c6475ff0c934ab95844e4884333a073f",
+    "usage": {
+      "prompt_tokens": 32768,
+      "total_tokens": 33280,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations performed as a single logical unit of work. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and is permanently saved to the database, or none of them are applied.\n\nTo understand why this is critical, consider a banking system. If you transfer \\$100 from Account A to Account B, two distinct operations occur:\n1. Subtract \\$100 from Account A.\n2. Add \\$100 to Account B.\n\nIf the system crashes after the first step but before the second, Account A loses money while Account B receives nothing. The money effectively vanishes into thin air. A database transaction prevents this by ensuring that both steps are treated as a single unit. If the second step fails, the first step is \"rolled back,\" and Account A\u2019s balance is restored.\n\n---\n\n### The ACID Properties: The Pillars of Transactions\n\nTo guarantee that transactions are processed reliably, database management systems (DBMS) must adhere to a set of four properties known as **ACID**.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as an indivisible unit. If a transaction consists of five different SQL queries, and the fourth one fails due to a power outage or a constraint violation, the database must undo the first three queries. The database state must return to exactly how it was before the transaction started.\n*   **Mechanism:** This is usually managed via a **Transaction Log** (or Write-Ahead Log). The system records every change before it happens. If a failure occurs, the system reads the log to \"undo\" (rollback) the partial changes.\n\n#### 2. Consistency (\"Follow the Rules\")\nConsistency ensures that a transaction brings the database from one valid state to another. Every database has predefined rules, such as \"account balances cannot be negative\" or \"every order must have a valid customer ID.\" A transaction must not violate these rules. If a transaction would result in an illegal state, the DBMS will abort the transaction.\n*   **Example:** If you try to transfer \\$500 from an account that only has \\$200, and the database has a \"no negative balance\" rule, the transaction will fail the consistency check and be"
+  },
+  {
+    "index": 1,
+    "start_seconds": 28.334020109003177,
+    "end_seconds": 56.67031894001411,
+    "ttft_seconds": 17.010497626004508,
+    "latency_seconds": 28.336298831010936,
+    "decode_tokens_per_second": 45.11846273339815,
+    "text_sha256": "776449f071272b7ffcaa722fc9113043c6475ff0c934ab95844e4884333a073f",
+    "usage": {
+      "prompt_tokens": 32768,
+      "total_tokens": 33280,
+      "completion_tokens": 512
+    },
+    "error": null,
+    "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations performed as a single logical unit of work. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and is permanently saved to the database, or none of them are applied.\n\nTo understand why this is critical, consider a banking system. If you transfer \\$100 from Account A to Account B, two distinct operations occur:\n1. Subtract \\$100 from Account A.\n2. Add \\$100 to Account B.\n\nIf the system crashes after the first step but before the second, Account A loses money while Account B receives nothing. The money effectively vanishes into thin air. A database transaction prevents this by ensuring that both steps are treated as a single unit. If the second step fails, the first step is \"rolled back,\" and Account A\u2019s balance is restored.\n\n---\n\n### The ACID Properties: The Pillars of Transactions\n\nTo guarantee that transactions are processed reliably, database management systems (DBMS) must adhere to a set of four properties known as **ACID**.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as an indivisible unit. If a transaction consists of five different SQL queries, and the fourth one fails due to a power outage or a constraint violation, the database must undo the first three queries. The database state must return to exactly how it was before the transaction started.\n*   **Mechanism:** This is usually managed via a **Transaction Log** (or Write-Ahead Log). The system records every change before it happens. If a failure occurs, the system reads the log to \"undo\" (rollback) the partial changes.\n\n#### 2. Consistency (\"Follow the Rules\")\nConsistency ensures that a transaction brings the database from one valid state to another. Every database has predefined rules, such as \"account balances cannot be negative\" or \"every order must have a valid customer ID.\" A transaction must not violate these rules. If a transaction would result in an illegal state, the DBMS will abort the transaction.\n*   **Example:** If you try to transfer \\$500 from an account that only has \\$200, and the database has a \"no negative balance\" rule, the transaction will fail the consistency check and be"
+  }
+]

evidence/http-p3c/tput-32768/summary.json

@@ -0,0 +1,24 @@
+{
+  "model": "google/gemma-4-12B-it",
+  "output_tokens": 512,
+  "method": "Closed loop; synchronized initial clients; max(min_requests,2*concurrency) requests; nearest-rank percentiles; aggregate includes prefill and queue drain",
+  "cases": [
+    {
+      "input_tokens": 32768,
+      "concurrency": 1,
+      "requests": 2,
+      "successes": 2,
+      "errors": 0,
+      "wall_seconds": 56.670300980011234,
+      "matching_single_request_outputs": 2,
+      "aggregate_output_tokens_per_second": 18.069429353501857,
+      "requests_per_second": 0.035291854206058314,
+      "ttft_seconds_p50": 16.9979730900086,
+      "ttft_seconds_p95": 17.010497626004508,
+      "latency_seconds_p50": 28.333959799987497,
+      "latency_seconds_p95": 28.336298831010936,
+      "decode_tokens_per_second_p50": 45.07796922419997,
+      "decode_tokens_per_second_p95": 45.11846273339815
+    }
+  ]
+}

evidence/http-p3c/tput-32768/warmup-32768.json

@@ -0,0 +1,16 @@
+{
+  "index": -1,
+  "start_seconds": 6.599875632673502e-07,
+  "end_seconds": 28.28398171698791,
+  "ttft_seconds": 16.959950836986536,
+  "latency_seconds": 28.283981057000346,
+  "decode_tokens_per_second": 45.125468318013986,
+  "text_sha256": "776449f071272b7ffcaa722fc9113043c6475ff0c934ab95844e4884333a073f",
+  "usage": {
+    "prompt_tokens": 32768,
+    "total_tokens": 33280,
+    "completion_tokens": 512
+  },
+  "error": null,
+  "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations performed as a single logical unit of work. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and is permanently saved to the database, or none of them are applied.\n\nTo understand why this is critical, consider a banking system. If you transfer \\$100 from Account A to Account B, two distinct operations occur:\n1. Subtract \\$100 from Account A.\n2. Add \\$100 to Account B.\n\nIf the system crashes after the first step but before the second, Account A loses money while Account B receives nothing. The money effectively vanishes into thin air. A database transaction prevents this by ensuring that both steps are treated as a single unit. If the second step fails, the first step is \"rolled back,\" and Account A\u2019s balance is restored.\n\n---\n\n### The ACID Properties: The Pillars of Transactions\n\nTo guarantee that transactions are processed reliably, database management systems (DBMS) must adhere to a set of four properties known as **ACID**.\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as an indivisible unit. If a transaction consists of five different SQL queries, and the fourth one fails due to a power outage or a constraint violation, the database must undo the first three queries. The database state must return to exactly how it was before the transaction started.\n*   **Mechanism:** This is usually managed via a **Transaction Log** (or Write-Ahead Log). The system records every change before it happens. If a failure occurs, the system reads the log to \"undo\" (rollback) the partial changes.\n\n#### 2. Consistency (\"Follow the Rules\")\nConsistency ensures that a transaction brings the database from one valid state to another. Every database has predefined rules, such as \"account balances cannot be negative\" or \"every order must have a valid customer ID.\" A transaction must not violate these rules. If a transaction would result in an illegal state, the DBMS will abort the transaction.\n*   **Example:** If you try to transfer \\$500 from an account that only has \\$200, and the database has a \"no negative balance\" rule, the transaction will fail the consistency check and be"
+}

evidence/http-p3c/tput-8192/summary.json

@@ -0,0 +1,24 @@
+{
+  "model": "google/gemma-4-12B-it",
+  "output_tokens": 512,
+  "method": "Closed loop; synchronized initial clients; max(min_requests,2*concurrency) requests; nearest-rank percentiles; aggregate includes prefill and queue drain",
+  "cases": [
+    {
+      "input_tokens": 8192,
+      "concurrency": 1,
+      "requests": 2,
+      "successes": 2,
+      "errors": 0,
+      "wall_seconds": 28.218357334000757,
+      "matching_single_request_outputs": 2,
+      "aggregate_output_tokens_per_second": 36.28843408139019,
+      "requests_per_second": 0.07087584781521522,
+      "ttft_seconds_p50": 3.2046391630137805,
+      "ttft_seconds_p95": 3.205977500998415,
+      "latency_seconds_p50": 14.10873377599637,
+      "latency_seconds_p95": 14.109585438010981,
+      "decode_tokens_per_second_p50": 46.86344028651859,
+      "decode_tokens_per_second_p95": 46.86549853892436
+    }
+  ]
+}

evidence/http-p3c/tput-8192/warmup-8192.json

@@ -0,0 +1,16 @@
+{
+  "index": -1,
+  "start_seconds": 7.8001176007092e-07,
+  "end_seconds": 14.163157122005941,
+  "ttft_seconds": 3.2000005510053597,
+  "latency_seconds": 14.163156341994181,
+  "decode_tokens_per_second": 46.61093577559656,
+  "text_sha256": "252ca3663ced10787639340f33bf875901dae772ac0d46b4b1f10ae78b0fcea9",
+  "usage": {
+    "prompt_tokens": 8192,
+    "total_tokens": 8704,
+    "completion_tokens": 512
+  },
+  "error": null,
+  "text": "### Understanding Database Transactions: A Comprehensive Guide\n\nIn the world of data management, a **database transaction** is a fundamental concept that ensures data integrity and reliability. At its simplest, a transaction is a sequence of one or more operations performed as a single logical unit of work. The core philosophy of a transaction is \"all or nothing\": either every operation within the transaction succeeds and is permanently saved, or none of them are applied to the database.\n\nThis concept is vital because, in real-world applications, a single action (like buying a product online) often involves multiple underlying database updates. If one update succeeds but another fails, the data becomes inconsistent, leading to errors like \"ghost\" inventory or missing payments. To prevent this, databases adhere to a set of properties known as **ACID**.\n\n---\n\n### The ACID Properties\n\nTo be considered a valid transaction, a database operation must satisfy four key properties:\n\n#### 1. Atomicity (\"All or Nothing\")\nAtomicity ensures that a transaction is treated as a single, indivisible unit. If a transaction consists of five steps and the system crashes at step four, the database must \"roll back\" the first three steps so that the database remains in its original state.\n*   **Example:** Imagine a bank transfer where \\$100 is moved from Account A to Account B. This involves two steps: (1) Subtract \\$100 from A, and (2) Add \\$100 to B. If the system fails after step one, Account A loses money while Account B gains nothing. Atomicity ensures that if step two fails, step one is undone.\n\n#### 2. Consistency (Valid State to Valid State)\nConsistency ensures that a transaction brings the database from one valid state to another, maintaining all predefined rules, including constraints, cascades, and triggers. A transaction cannot leave the database in a \"broken\" state (e.g., a negative balance in an account that doesn't allow it).\n*   **Example:** If a database has a rule that \"Total Assets must equal Total Liabilities,\" any transaction that would cause this equation to be unbalanced will be rejected by the system.\n\n#### 3. Isolation (Independence of Transactions)\nIn a multi-user environment, hundreds of people might be accessing the same database simultaneously. Isolation ensures that concurrent transactions do not interfere with each other. The result of running multiple transactions at the same time should be the same as if they were run one after another (sequentially)."
+}

evidence/http-p3c/tput_vs_direct.json

@@ -0,0 +1,22 @@
+[
+ {
+  "ctx": 32768,
+  "direct_tokens": 512,
+  "http_requests": 3,
+  "identical": [
+   true,
+   true,
+   true
+  ]
+ },
+ {
+  "ctx": 261632,
+  "direct_tokens": 512,
+  "http_requests": 3,
+  "identical": [
+   true,
+   true,
+   true
+  ]
+ }
+]

evidence/localmaxxing/speed-test.json

@@ -0,0 +1,175 @@
+{
+  "agentFeedback": {
+    "benchmarkStatus": "completed",
+    "canApiValidate": true,
+    "canSubmit": true,
+    "engine": "vllm",
+    "message": "Speed-test payload is ready for API validation.",
+    "mode": "remote",
+    "nextCommand": "lmx speed-test dry-run /var/tmp/gemma4-12b/runs/lmx-official/speed-test.json",
+    "outputPath": "/var/tmp/gemma4-12b/runs/lmx-official/speed-test.json",
+    "outputPathAbsolute": "/var/tmp/gemma4-12b/runs/lmx-official/speed-test.json",
+    "requiresMetrics": false,
+    "runPersisted": true,
+    "savedRunPath": "/var/tmp/gemma4-12b/runs/lmx-official/runs/google-gemma-4-12B-it/20260930T163215Z.json",
+    "savedRunPathAbsolute": "/var/tmp/gemma4-12b/runs/lmx-official/runs/google-gemma-4-12B-it/20260930T163215Z.json",
+    "savedRunPathRelative": "/var/tmp/gemma4-12b/runs/lmx-official/runs/google-gemma-4-12B-it/20260930T163215Z.json",
+    "status": "ready_for_api_validation",
+    "submissionStatus": "ready",
+    "submitCommand": "lmx speed-test submit /var/tmp/gemma4-12b/runs/lmx-official/speed-test.json"
+  },
+  "backend": "tt-metal",
+  "batchSize": 1,
+  "benchmarkMode": "remote",
+  "contextLength": 262144,
+  "detectedEngines": [
+    {
+      "name": "llama.cpp",
+      "installed": true,
+      "binaries": {
+        "llama-bench": "/home/lotto/llama.cpp/build/bin/llama-bench",
+        "llama-cli": "/home/lotto/llama.cpp/build/bin/llama-cli",
+        "llama-server": "/home/lotto/llama.cpp/build/bin/llama-server"
+      }
+    }
+  ],
+  "engineFlags": {
+    "baseUrl": "http://127.0.0.1:8002",
+    "concurrency": 1,
+    "iterations": 5,
+    "maxTokens": 256,
+    "mode": "remote",
+    "prefixCacheBust": "leading_nonce_per_request",
+    "promptFile": "",
+    "promptSource": "default",
+    "servedModel": "google/gemma-4-12B-it",
+    "servedModelSource": "explicit",
+    "specDecoding": true,
+    "specDraftModel": "google/gemma-4-12B-it-assistant",
+    "specMethod": "assistant",
+    "specNumTokens": 5,
+    "stream": true,
+    "timeoutSeconds": 600,
+    "warmup": 2
+  },
+  "engineName": "vllm",
+  "hardware": {
+    "cpu": "AMD Ryzen 9 9950X",
+    "gpuCount": 1,
+    "gpuName": "Tenstorrent P150",
+    "hwClass": "DISCRETE_GPU",
+    "os": "Ubuntu 26.04 LTS",
+    "ramGb": 96,
+    "vramGb": 32
+  },
+  "hardwareSource": "file",
+  "hfId": "google/gemma-4-12B-it",
+  "metricSource": "remote_endpoint",
+  "modelRevision": "main",
+  "notes": "Single Tenstorrent P150, gemma4-12b:p3c, all-BFP8 native weights with exact proof, it-assistant drafter K=5, greedy. Local run, not submitted.",
+  "outputText": "To accurately evaluate the performance of a local Large Language Model (LLM) inference engine, reporting only a single \"tokens per second\" (TPS) metric is misleading. Because the computational demands of LLMs change drastically depending on whether the model is \"thinking\" (processing input) or \"speaking\" (generating output), you must break down performance into three distinct metrics: **Prompt Prefill Throughput**, **Decode Throughput**, and **Time to First Token (TTFT)**.\n\nHere is the technical breakdown of why each is essential:\n\n---\n\n### 1. Prompt Prefill Throughput (The \"Ingestion\" Phase)\n**What it is:** The speed at which the model processes the input prompt and converts it into the initial KV (Key-Value) cache.\n\n*   **Why it matters:** This is a **compute-bound** operation. During prefill, the GPU processes all input tokens in parallel. If you are summarizing a 10,000-word document or analyzing a massive codebase, the prefill speed determines how long the user has to wait before the model starts \"typing.\"\n*   **The Hardware Context:** High prefill throughput indicates efficient utilization of the GPU's CUDA cores and high memory bandwidth",
+  "outputTokens": 256,
+  "prefillTokens": 0,
+  "prompt": "Explain why local inference speed tests should report prompt prefill throughput, decode throughput, and time to first token.",
+  "promptTokens": 75,
+  "provenance": {
+    "benchmarkMode": "remote",
+    "cli": "localmaxxing-go",
+    "createdAt": "2026-09-30T16:32:15Z",
+    "metricSource": "remote_endpoint",
+    "timingSource": "client_observed_http",
+    "ttftSource": "stream_first_token"
+  },
+  "quantization": "BFP8",
+  "quantizationResolution": {
+    "cli": "BFP8",
+    "status": "matched",
+    "trusted": "BFP8",
+    "trustedSource": "cli"
+  },
+  "sampleStats": {
+    "tokSOut": {
+      "count": 5,
+      "max": 52.2,
+      "mean": 50.46,
+      "min": 49.3,
+      "p50": 49.9,
+      "stddev": 1.15
+    },
+    "tokSTotal": {
+      "count": 5,
+      "max": 66.2,
+      "mean": 64.24,
+      "min": 63.2,
+      "p50": 63.5,
+      "stddev": 1.35
+    },
+    "ttftMs": {
+      "count": 5,
+      "max": 95.37,
+      "mean": 94.96,
+      "min": 94.31,
+      "p50": 95.29,
+      "stddev": 0.51
+    }
+  },
+  "samples": [
+    {
+      "iteration": 1,
+      "outputTokens": 256,
+      "promptTokens": 75,
+      "request": 1,
+      "tokSOut": 49.9,
+      "tokSPrefill": 795.3,
+      "ttftMs": 94.31
+    },
+    {
+      "iteration": 2,
+      "outputTokens": 256,
+      "promptTokens": 77,
+      "request": 1,
+      "tokSOut": 49.3,
+      "tokSPrefill": 808.1,
+      "ttftMs": 95.29
+    },
+    {
+      "iteration": 3,
+      "outputTokens": 256,
+      "promptTokens": 76,
+      "request": 1,
+      "tokSOut": 51,
+      "tokSPrefill": 797.4,
+      "ttftMs": 95.31
+    },
+    {
+      "iteration": 4,
+      "outputTokens": 256,
+      "promptTokens": 73,
+      "request": 1,
+      "tokSOut": 49.9,
+      "tokSPrefill": 772.5,
+      "ttftMs": 94.5
+    },
+    {
+      "iteration": 5,
+      "outputTokens": 256,
+      "promptTokens": 74,
+      "request": 1,
+      "tokSOut": 52.2,
+      "tokSPrefill": 775.9,
+      "ttftMs": 95.37
+    }
+  ],
+  "timingSource": "client_observed_http",
+  "tokSOut": 49.9,
+  "tokSOutSource": "inter_token",
+  "tokSPrefill": 795.3,
+  "tokSPrefillSource": "estimated_from_ttft",
+  "tokSTotal": 63.5,
+  "tokenSources": {
+    "output": "endpoint_usage",
+    "prompt": "endpoint_usage"
+  },
+  "ttftMs": 95.29,
+  "ttftSource": "stream_first_token"
+}

evidence/quality/quant_table.json

@@ -0,0 +1,533 @@
+{
+ "ref_ppl": {
+  "chat": 8.5587,
+  "code": 5.6556,
+  "long-book": 12.1535,
+  "short-all": 7.1382
+ },
+ "gsm8k_bf16_cpu_acc": 0.98,
+ "rows": [
+  {
+   "config": "bf16",
+   "plan": "plans/bf16.json",
+   "weights": "IT",
+   "read_GB": 23.8446,
+   "floor_ms@128": 46.66,
+   "chat": {
+    "ppl_delta_pct": -0.77,
+    "dnll": -0.0077,
+    "se": 0.0014,
+    "top1": 0.975,
+    "kl": 0.0095,
+    "kl_p99": 0.103
+   },
+   "code": {
+    "ppl_delta_pct": -0.05,
+    "dnll": -0.0005,
+    "se": 0.0014,
+    "top1": 0.9843,
+    "kl": 0.0139,
+    "kl_p99": 0.061
+   },
+   "long-book": {
+    "ppl_delta_pct": -0.14,
+    "dnll": -0.0014,
+    "se": 0.0013,
+    "top1": 0.9764,
+    "kl": 0.0048,
+    "kl_p99": 0.053
+   },
+   "short-all": {
+    "ppl_delta_pct": -0.45,
+    "dnll": -0.0045,
+    "se": 0.001,
+    "top1": 0.9791,
+    "kl": 0.0114,
+    "kl_p99": 0.081
+   }
+  },
+  {
+   "config": "a-bfp8",
+   "plan": "plans/a-bfp8.json",
+   "weights": "IT",
+   "read_GB": 12.6675,
+   "floor_ms@128": 24.83,
+   "chat": {
+    "ppl_delta_pct": -0.29,
+    "dnll": -0.0029,
+    "se": 0.0015,
+    "top1": 0.9713,
+    "kl": 0.0122,
+    "kl_p99": 0.139
+   },
+   "code": {
+    "ppl_delta_pct": 1.01,
+    "dnll": 0.01,
+    "se": 0.0014,
+    "top1": 0.9827,
+    "kl": 0.0057,
+    "kl_p99": 0.08
+   },
+   "long-book": {
+    "ppl_delta_pct": 1.61,
+    "dnll": 0.016,
+    "se": 0.0015,
+    "top1": 0.9723,
+    "kl": 0.007,
+    "kl_p99": 0.068
+   },
+   "short-all": {
+    "ppl_delta_pct": 0.28,
+    "dnll": 0.0028,
+    "se": 0.001,
+    "top1": 0.9763,
+    "kl": 0.0093,
+    "kl_p99": 0.105
+   }
+  },
+  {
+   "config": "a-lm4",
+   "plan": "plans/a-lm4.json",
+   "weights": "IT",
+   "read_GB": 12.1641,
+   "floor_ms@128": 23.84,
+   "chat": {
+    "ppl_delta_pct": 0.61,
+    "dnll": 0.0061,
+    "se": 0.0018,
+    "top1": 0.955,
+    "kl": 0.0208,
+    "kl_p99": 0.244
+   },
+   "code": {
+    "ppl_delta_pct": 1.98,
+    "dnll": 0.0196,
+    "se": 0.0022,
+    "top1": 0.9703,
+    "kl": 0.0169,
+    "kl_p99": 0.289
+   },
+   "long-book": {
+    "ppl_delta_pct": 2.55,
+    "dnll": 0.0252,
+    "se": 0.0023,
+    "top1": 0.9605,
+    "kl": 0.0149,
+    "kl_p99": 0.128
+   },
+   "short-all": {
+    "ppl_delta_pct": 1.21,
+    "dnll": 0.012,
+    "se": 0.0014,
+    "top1": 0.9617,
+    "kl": 0.0191,
+    "kl_p99": 0.264
+   }
+  },
+  {
+   "config": "f-dn4",
+   "plan": "plans/f-dn4.json",
+   "weights": "IT",
+   "read_GB": 11.2519,
+   "floor_ms@128": 22.06,
+   "chat": {
+    "ppl_delta_pct": 2.61,
+    "dnll": 0.0257,
+    "se": 0.004,
+    "top1": 0.9102,
+    "kl": 0.0942,
+    "kl_p99": 1.456
+   },
+   "code": {
+    "ppl_delta_pct": 2.43,
+    "dnll": 0.024,
+    "se": 0.005,
+    "top1": 0.9333,
+    "kl": 0.101,
+    "kl_p99": 1.949
+   },
+   "long-book": {
+    "ppl_delta_pct": -0.64,
+    "dnll": -0.0065,
+    "se": 0.0049,
+    "top1": 0.912,
+    "kl": 0.0732,
+    "kl_p99": 0.819
+   },
+   "short-all": {
+    "ppl_delta_pct": 2.53,
+    "dnll": 0.025,
+    "se": 0.0031,
+    "top1": 0.9203,
+    "kl": 0.0972,
+    "kl_p99": 1.65
+   }
+  },
+  {
+   "config": "f-gu4",
+   "plan": "plans/f-gu4.json",
+   "weights": "IT",
+   "read_GB": 9.8363,
+   "floor_ms@128": 19.3,
+   "chat": {
+    "ppl_delta_pct": 1.56,
+    "dnll": 0.0155,
+    "se": 0.004,
+    "top1": 0.9021,
+    "kl": 0.0962,
+    "kl_p99": 1.461
+   },
+   "code": {
+    "ppl_delta_pct": 2.43,
+    "dnll": 0.024,
+    "se": 0.0051,
+    "top1": 0.9286,
+    "kl": 0.1111,
+    "kl_p99": 2.099
+   },
+   "long-book": {
+    "ppl_delta_pct": 9.73,
+    "dnll": 0.0929,
+    "se": 0.0053,
+    "top1": 0.9053,
+    "kl": 0.0848,
+    "kl_p99": 0.863
+   },
+   "short-all": {
+    "ppl_delta_pct": 1.94,
+    "dnll": 0.0192,
+    "se": 0.0032,
+    "top1": 0.9137,
+    "kl": 0.1028,
+    "kl_p99": 1.702
+   }
+  },
+  {
+   "config": "g-rank3072",
+   "plan": "plans/g-rank3072.json",
+   "weights": "IT",
+   "read_GB": 11.6058,
+   "floor_ms@128": 22.75,
+   "chat": {
+    "ppl_delta_pct": -0.04,
+    "dnll": -0.0004,
+    "se": 0.0031,
+    "top1": 0.9308,
+    "kl": 0.0548,
+    "kl_p99": 0.837
+   },
+   "code": {
+    "ppl_delta_pct": 2.05,
+    "dnll": 0.0203,
+    "se": 0.0041,
+    "top1": 0.9478,
+    "kl": 0.0688,
+    "kl_p99": 1.243
+   },
+   "long-book": {
+    "ppl_delta_pct": 7.3,
+    "dnll": 0.0704,
+    "se": 0.0037,
+    "top1": 0.9422,
+    "kl": 0.036,
+    "kl_p99": 0.353
+   },
+   "short-all": {
+    "ppl_delta_pct": 0.87,
+    "dnll": 0.0087,
+    "se": 0.0025,
+    "top1": 0.9382,
+    "kl": 0.061,
+    "kl_p99": 1.024
+   }
+  },
+  {
+   "config": "g-rank2048",
+   "plan": "plans/g-rank2048.json",
+   "weights": "IT",
+   "read_GB": 10.5441,
+   "floor_ms@128": 20.68,
+   "chat": {
+    "ppl_delta_pct": 1.25,
+    "dnll": 0.0125,
+    "se": 0.0037,
+    "top1": 0.9126,
+    "kl": 0.082,
+    "kl_p99": 1.28
+   },
+   "code": {
+    "ppl_delta_pct": 1.82,
+    "dnll": 0.018,
+    "se": 0.0048,
+    "top1": 0.9349,
+    "kl": 0.0971,
+    "kl_p99": 1.813
+   },
+   "long-book": {
+    "ppl_delta_pct": 8.86,
+    "dnll": 0.0849,
+    "se": 0.0048,
+    "top1": 0.9169,
+    "kl": 0.0671,
+    "kl_p99": 0.713
+   },
+   "short-all": {
+    "ppl_delta_pct": 1.5,
+    "dnll": 0.0149,
+    "se": 0.003,
+    "top1": 0.9224,
+    "kl": 0.0886,
+    "kl_p99": 1.542
+   }
+  },
+  {
+   "config": "b-mlp4",
+   "plan": "plans/b-mlp4.json",
+   "weights": "IT",
+   "read_GB": 8.4207,
+   "floor_ms@128": 16.53,
+   "chat": {
+    "ppl_delta_pct": 5.17,
+    "dnll": 0.0504,
+    "se": 0.0052,
+    "top1": 0.8706,
+    "kl": 0.1747,
+    "kl_p99": 2.743
+   },
+   "code": {
+    "ppl_delta_pct": 3.91,
+    "dnll": 0.0383,
+    "se": 0.0066,
+    "top1": 0.9083,
+    "kl": 0.1758,
+    "kl_p99": 3.069
+   },
+   "long-book": {
+    "ppl_delta_pct": 9.91,
+    "dnll": 0.0945,
+    "se": 0.007,
+    "top1": 0.8769,
+    "kl": 0.1502,
+    "kl_p99": 1.589
+   },
+   "short-all": {
+    "ppl_delta_pct": 4.61,
+    "dnll": 0.0451,
+    "se": 0.0041,
+    "top1": 0.8871,
+    "kl": 0.1752,
+    "kl_p99": 2.848
+   }
+  },
+  {
+   "config": "c-mlp4-lm4",
+   "plan": "plans/c-mlp4-lm4.json",
+   "weights": "IT",
+   "read_GB": 7.9174,
+   "floor_ms@128": 15.55,
+   "chat": {
+    "ppl_delta_pct": 6.21,
+    "dnll": 0.0603,
+    "se": 0.0054,
+    "top1": 0.8667,
+    "kl": 0.186,
+    "kl_p99": 2.85
+   },
+   "code": {
+    "ppl_delta_pct": 4.99,
+    "dnll": 0.0487,
+    "se": 0.0069,
+    "top1": 0.9057,
+    "kl": 0.1882,
+    "kl_p99": 3.352
+   },
+   "long-book": {
+    "ppl_delta_pct": 10.8,
+    "dnll": 0.1026,
+    "se": 0.0072,
+    "top1": 0.874,
+    "kl": 0.1582,
+    "kl_p99": 1.699
+   },
+   "short-all": {
+    "ppl_delta_pct": 5.67,
+    "dnll": 0.0552,
+    "se": 0.0043,
+    "top1": 0.8838,
+    "kl": 0.1869,
+    "kl_p99": 3.089
+   }
+  },
+  {
+   "config": "e-all4",
+   "plan": "plans/e-all4.json",
+   "weights": "IT",
+   "read_GB": 7.2096,
+   "floor_ms@128": 14.17,
+   "chat": {
+    "ppl_delta_pct": 7.24,
+    "dnll": 0.0699,
+    "se": 0.0068,
+    "top1": 0.8266,
+    "kl": 0.2946,
+    "kl_p99": 4.066
+   },
+   "code": {
+    "ppl_delta_pct": 8.32,
+    "dnll": 0.0799,
+    "se": 0.0085,
+    "top1": 0.8736,
+    "kl": 0.2975,
+    "kl_p99": 4.776
+   },
+   "long-book": {
+    "ppl_delta_pct": 19.16,
+    "dnll": 0.1753,
+    "se": 0.0107,
+    "top1": 0.8009,
+    "kl": 0.3806,
+    "kl_p99": 3.648
+   },
+   "short-all": {
+    "ppl_delta_pct": 7.71,
+    "dnll": 0.0743,
+    "se": 0.0053,
+    "top1": 0.8472,
+    "kl": 0.2959,
+    "kl_p99": 4.394
+   }
+  },
+  {
+   "config": "e-all4-lm4",
+   "plan": "plans/e-all4-lm4.json",
+   "weights": "IT",
+   "read_GB": 6.7063,
+   "floor_ms@128": 13.18,
+   "chat": {
+    "ppl_delta_pct": 8.48,
+    "dnll": 0.0814,
+    "se": 0.0069,
+    "top1": 0.824,
+    "kl": 0.3089,
+    "kl_p99": 4.273
+   },
+   "code": {
+    "ppl_delta_pct": 9.76,
+    "dnll": 0.0931,
+    "se": 0.0087,
+    "top1": 0.8709,
+    "kl": 0.3114,
+    "kl_p99": 5.03
+   },
+   "long-book": {
+    "ppl_delta_pct": 19.92,
+    "dnll": 0.1816,
+    "se": 0.0108,
+    "top1": 0.7996,
+    "kl": 0.3899,
+    "kl_p99": 3.703
+   },
+   "short-all": {
+    "ppl_delta_pct": 9.04,
+    "dnll": 0.0865,
+    "se": 0.0055,
+    "top1": 0.8446,
+    "kl": 0.31,
+    "kl_p99": 4.618
+   }
+  },
+  {
+   "config": "d-qat-a",
+   "plan": "plans/a-bfp8.json",
+   "weights": "QAT",
+   "read_GB": 12.6675,
+   "floor_ms@128": 24.83,
+   "chat": {
+    "ppl_delta_pct": -2.86,
+    "dnll": -0.029,
+    "se": 0.0053,
+    "top1": 0.9074,
+    "kl": 0.1289,
+    "kl_p99": 2.267
+   },
+   "code": {
+    "ppl_delta_pct": -8.9,
+    "dnll": -0.0932,
+    "se": 0.0059,
+    "top1": 0.928,
+    "kl": 0.1018,
+    "kl_p99": 1.497
+   },
+   "long-book": {
+    "ppl_delta_pct": -4.87,
+    "dnll": -0.0499,
+    "se": 0.0054,
+    "top1": 0.9055,
+    "kl": 0.0771,
+    "kl_p99": 0.782
+   },
+   "short-all": {
+    "ppl_delta_pct": -5.55,
+    "dnll": -0.0571,
+    "se": 0.0039,
+    "top1": 0.9164,
+    "kl": 0.117,
+    "kl_p99": 2.004
+   }
+  },
+  {
+   "config": "d-qat-b",
+   "plan": "plans/b-mlp4.json",
+   "weights": "QAT",
+   "read_GB": 8.4207,
+   "floor_ms@128": 16.53,
+   "chat": {
+    "ppl_delta_pct": 0.98,
+    "dnll": 0.0098,
+    "se": 0.0062,
+    "top1": 0.8658,
+    "kl": 0.2104,
+    "kl_p99": 3.608
+   },
+   "code": {
+    "ppl_delta_pct": -0.85,
+    "dnll": -0.0086,
+    "se": 0.0075,
+    "top1": 0.8987,
+    "kl": 0.1855,
+    "kl_p99": 3.064
+   },
+   "long-book": {
+    "ppl_delta_pct": 6.68,
+    "dnll": 0.0647,
+    "se": 0.0074,
+    "top1": 0.8719,
+    "kl": 0.1512,
+    "kl_p99": 1.517
+   },
+   "short-all": {
+    "ppl_delta_pct": 0.18,
+    "dnll": 0.0018,
+    "se": 0.0048,
+    "top1": 0.8802,
+    "kl": 0.1995,
+    "kl_p99": 3.406
+   }
+  }
+ ],
+ "gsm8k_50": {
+  "a-lm4": {
+   "acc": 0.98,
+   "agree": 0.96
+  },
+  "a-bfp8": {
+   "acc": 1.0,
+   "agree": 0.98
+  },
+  "b-mlp4": {
+   "acc": 0.98,
+   "agree": 0.96
+  }
+ },
+ "pick": "a-lm4"
+}

evidence/quality/runtime-gate-dtf-score.json

@@ -0,0 +1,41 @@
+{
+ "chat": {
+  "n": 5888,
+  "dNLL": 0.010796350426971912,
+  "se": 0.002044405456103154,
+  "dPPL_pct": 1.0854721069335938,
+  "top1": 0.9799592391304348,
+  "kl_mean": 0.0037473044358193874,
+  "kl_p99": 0.04619763791561127,
+  "vs_base_dNLL": 0.001731055905111134,
+  "vs_base_se": 0.0011998895297415893,
+  "vs_base_top1_pts": 0.06793478260870289,
+  "argmax_agree_base": 0.98828125
+ },
+ "code": {
+  "n": 3328,
+  "dNLL": 0.004894797224551439,
+  "se": 0.00325290915414018,
+  "dPPL_pct": 0.4906773567199707,
+  "top1": 0.9846754807692307,
+  "kl_mean": 0.005180150270462036,
+  "kl_p99": 0.08787598460912704,
+  "vs_base_dNLL": -0.0004120908852200955,
+  "vs_base_se": 0.0030019859298719472,
+  "vs_base_top1_pts": -0.09014423076924016,
+  "argmax_agree_base": 0.9879807692307693
+ },
+ "long-book": {
+  "n": 256,
+  "dNLL": 0.0037011178210377693,
+  "se": 0.014648807235062122,
+  "dPPL_pct": 0.37078857421875,
+  "top1": 0.96484375,
+  "kl_mean": 0.008751568384468555,
+  "kl_p99": 0.09284984320402145,
+  "vs_base_dNLL": -0.006091505289077759,
+  "vs_base_se": 0.009644112549722195,
+  "vs_base_top1_pts": -0.390625,
+  "argmax_agree_base": 0.984375
+ }
+}

gemma-4-12B-it-assistant/config.json

@@ -0,0 +1,88 @@
+{
+  "architectures": [
+    "Gemma4UnifiedAssistantForCausalLM"
+  ],
+  "audio_token_id": 258881,
+  "backbone_hidden_size": 3840,
+  "boa_token_id": 256000,
+  "boi_token_id": 255999,
+  "centroid_intermediate_top_k": 32,
+  "dtype": "bfloat16",
+  "eoa_token_index": 258883,
+  "eoi_token_id": 258882,
+  "image_token_id": 258880,
+  "model_type": "gemma4_unified_assistant",
+  "num_centroids": 2048,
+  "text_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attention_k_eq_v": true,
+    "bos_token_id": 2,
+    "chunk_size_feed_forward": 0,
+    "dtype": "bfloat16",
+    "enable_moe_block": false,
+    "eos_token_id": 1,
+    "final_logit_softcapping": null,
+    "global_head_dim": 512,
+    "head_dim": 256,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 1024,
+    "hidden_size_per_layer_input": 0,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "intermediate_size": 8192,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_types": [
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 262144,
+    "model_type": "gemma4_unified_text",
+    "moe_intermediate_size": null,
+    "num_attention_heads": 16,
+    "num_experts": null,
+    "num_global_key_value_heads": 1,
+    "num_hidden_layers": 4,
+    "num_key_value_heads": 8,
+    "num_kv_shared_layers": 4,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "pad_token_id": 0,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "full_attention": {
+        "partial_rotary_factor": 0.25,
+        "rope_theta": 1000000.0,
+        "rope_type": "proportional"
+      },
+      "sliding_attention": {
+        "rope_theta": 10000.0,
+        "rope_type": "default"
+      }
+    },
+    "sliding_window": 1024,
+    "tie_word_embeddings": true,
+    "top_k_experts": null,
+    "use_bidirectional_attention": "vision",
+    "use_cache": true,
+    "use_double_wide_mlp": false,
+    "vocab_size": 262144,
+    "vocab_size_per_layer_input": 0
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.10.0.dev0",
+  "use_ordered_embeddings": false
+}

gemma-4-12B-it-assistant/drafter_manifest.json

@@ -0,0 +1,285 @@
+{
+ "builder_runtime_identity": {
+  "binaries": {
+   "build/lib/_ttnncpp.so": "72186b132bf7be85bbb6e1b54bf6de125fbd7a557b12711c84efc6d3e2e08f8d",
+   "build/lib/libtt_metal.so": "0497308232f180a0973406e2afd290b9eafa9e310a16b09bf69acc4434eb0e78",
+   "ttnn/ttnn/_ttnn.so": "a6448405abd714d6ba310dbbc409c01842f42017b8c1d6bb1c30503fb194c7b2"
+  },
+  "gemma4_tree": {
+   "__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "config.py": "ca64c3f783bd7135bec21e2c765004f311631539129ad7ab592b8ae15a2474e4",
+   "conftest.py": "5c9425f9367d48a2873dc83ae074bb0cf62fc433a5c8d140cf030930baf4c4ec",
+   "demo/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "demo/text_demo.py": "c95cee077db887fd748b4b32cf30f0751d21d14596cc0243048a4afafce98988",
+   "demo/text_demo_v2.py": "ad4785b8539e4fdeb32583932e6ac6e2d9bb342edb79d153f5d123d9b323a7d0",
+   "tt/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "tt/assistant/__init__.py": "229bb6de453e5f58c9c6bc80368cc417cc943ac0d6a6a268b845e91198ca2aa2",
+   "tt/assistant/model.py": "0e3247c34a359a73bd4c8ecc7365e028372084554eeeba41682d1fd818c296af",
+   "tt/attention/__init__.py": "5fef2a905f61e36f8a8ebfa19913460dac6845bb370f5688829bf514f0030400",
+   "tt/attention/config.py": "01b0f3e14c31aae5ed01104aee7f4cb03913007c0d0018f9d35d341d3fe049ef",
+   "tt/attention/decode.py": "d517d0f1df07be038658f77fd19d0e42c7ca7241efe8c59f3479576f7cb65042",
+   "tt/attention/kv_cache.py": "3a1e9f520cdde61dd49550dbfca1072d009ee34878bafe5923c655821c09bff7",
+   "tt/attention/kv_cache_hybrid.py": "9074a2d1de4b3a65d11271370f1fce39a78e5523b841752bcaa87dccb4b56470",
+   "tt/attention/operations.py": "f5cda2ade4031a66e631a732199f3b4b9a00b45ef2e252aee0d3138406bbcc43",
+   "tt/attention/prefill.py": "32c6e1c9423b9c22f14558c33d76d9164cb8a27c939cb5d1ccb6da039b7c831f",
+   "tt/attention/weights.py": "3ec94d60c6d1085bed0bf83fbc450aa9599a476341d3c6d77466b1b2e17c00d6",
+   "tt/ccl.py": "3580f2e25950381465e55dd2886d2832c33d8d6fc618b5a2b94088d0b1a91105",
+   "tt/common.py": "7e1a088a2f666cfef32e891dbe43ad143e15f1318a91ca895b4216bdfb68ca2e",
+   "tt/decode_mm.py": "978c6f7b111bfd652ac7e00f5c7ca90afc9699480ee9fc0be1614e1d43d3a1c1",
+   "tt/experts/__init__.py": "567aef533a30a692e4c0b28695c15d13e2cfc024ee621e4147c836b63220d5c3",
+   "tt/experts/config.py": "80bd7d18ffd0e0b6bd969d05a8e9972ff8473dc63631f1cb6de0bd619a50f33b",
+   "tt/experts/decode.py": "112b9df4b88e8395053fdbf69315e3a43e9f3f4877e699ca5a48462ccd8e804b",
+   "tt/experts/operations.py": "27db30001f4280dc46bd500d5d811f56ccd8a0896d4eb9f90a6ef50e9af3355b",
+   "tt/experts/prefill.py": "5f07a86da85d5ba64838e03d6627c7a78ccfcc06ebfbdaff39d8f7b52f84948d",
+   "tt/experts/weights.py": "dda56687ff669a92b8447dc098e4cad6007f94d66b642f1da48c17abd8568916",
+   "tt/gemma4_attention_config.py": "8e892a13f89acadd2415719c7c22d188ee906f5fabb1d326464b65afa06816be",
+   "tt/gemma4_expert_config.py": "e7b1037156bc3f20cacba6e7a59c5456ebaefa3ed772310f7476908b26aaf20a",
+   "tt/generator.py": "34914394ca36e2bc5942b28710ebc7362d7b610c4eb2db33745311b391ceee9e",
+   "tt/generator_trace.py": "d5c303e5fe936bf32d097d4013336dcfc587a3a2502cd71fd266c00ab6e2c9f3",
+   "tt/generator_vllm.py": "e3b9831358e44e6bcc1433e39ea13b82a7c15565826a38a00815a8a7640b65a4",
+   "tt/greedy_decode.py": "7604d9098ca2a36ba736eed21a2728dc72988c5ade03a1f6d8ce99c84d4ae5a4",
+   "tt/kernels/kv_rows_write.cpp": "f7419aa0ae5b10049546c4615780d53b6b54518c5f79ca76c708f1f76ce593ac",
+   "tt/layer.py": "e3261517b9328d460f84dd888f13694bb50047eb70240e6cc1967f16803599e0",
+   "tt/model.py": "9de68e12eb996f9f717d04f63dd42eb6b8cdbcc558d5c1789dc746ee25c7cc18",
+   "tt/model_config.py": "04ecd4a462f1ba726186e2c7fce7c3c86b78faf21091af9c9c098f325bb9556d",
+   "tt/moe.py": "37d5c5921fe9e5dc61f7b788bc0b3dfec349ce17915dc5450cf286a217f64e41",
+   "tt/precision.py": "588e9c3f9864c248175f0c8b2c8b45a5e45511568f71d448cf8ed1621c1d6571",
+   "tt/rms_norm.py": "cf0f9fb6191ae3d94191aa62a81686eeccb46b6c44635a1c75967d803886b213",
+   "tt/router.py": "61cfcfc0f6b3a7899f8d0b0a9de3738d8af933602e30d2fc4550c05ea9b19ff9",
+   "tt/shared_mlp.py": "31003feda56e095a8f871b210795306d1e988c0db3a860e799c4b025ee7f40db",
+   "tt/spec_decode.py": "8acf4609aca527c123b5d064236d4e817bca7e481702ad6580c0c417a30885e7",
+   "tt/spec_greedy.py": "1d3a4b1820f55eda775bcf4c56a93b24c13ecf8836f626185e191a6a95ebbd20",
+   "utils/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "utils/general_utils.py": "df7324ddc31c12d8177ae8ff007a220cb6e298b3ade498205ecaf5e93abe1eb9",
+   "utils/substate.py": "dd0c86aa2b1d6131d45f09ede19690e559543c51dc1166c858277a5c183963ac"
+  }
+ },
+ "dtype": "bfp8-lm4",
+ "files": {
+  "config.json": {
+   "bytes": 2346,
+   "sha256": "b6f19209588fcefe41f65b193fad6148446253c470d36e29441ecc5158a54e6d"
+  },
+  "generation_config.json": {
+   "bytes": 233,
+   "sha256": "02b56bd11e1cd1e363e701a85a2fd7fbaa2992ec3358c1cd7cc44ead7208f505"
+  },
+  "model.safetensors": {
+   "bytes": 845719296,
+   "sha256": "3279c173daddd7186e79d652ad94022415736d3a1370625696c898429b06d6df"
+  },
+  "tensors/assistant_tensor_cache_bfp8/final_norm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "70eb60efff28b3606bbc91b35a3311e7b4ccae3b70e0f3787c9c0b32cc4ebf3c"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/input_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "1179fa4a06ab8e4bae470dce5c4848d5b3b5eca1a3c87d8a02001bfb1aacf02f"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/mlp/down_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "bc68d0c960e2782993ff0d354800e3f4d67dd80d1b31f0775dc5574114402787"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/mlp/gate_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "eab412d5d2c21880e9be0f06a8814e649f54995eacf78cdcc1f57b4c0914c97a"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/mlp/up_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "87737fd7e41bf956bf99c709389f994710633f5271f7b1a34899fc64097f3465"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/post_attention_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "c7134e87abbbd99a3613b87356b26910c67c4dc88481883473a48a592e105ab9"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/post_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "f36ac602315f100f55e2ff60dd2d433f416e5088b7a1e132374d4fb5507d0ffa"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/pre_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "41226b5616d8526fa29f4b1d160a9aafab622c4520ad0aa5ac3d751ed105e87e"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/self_attn/k_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 856,
+   "sha256": "196c1590df83891269c77d8e3c0f3e04644d5c7d30985bd4990b2056854fbd43"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/self_attn/o_proj_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 4456816,
+   "sha256": "25138aecfea86617289b887c60e290cffc48d091f8dea8f3e6c7aa93a8145c13"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/self_attn/q_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 856,
+   "sha256": "5f7bc4231c79615214a55cc24b23ed92fb8f280d8889294a1b9e510159b16c2a"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_0/layer_0/self_attn/wqkv_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "8ebb3b5a6fcef326e40a9beaff4b49628ee07a46ca9a8b54d1ed03eddfbee967"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/input_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "16eeab1537e1770d8b129c67297def6e3792eadcc099663258f2da865eea7efd"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/mlp/down_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "60bd4ccea8173ae93aa96501d09a24507e30c1732e389550c8971b9197e7b412"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/mlp/gate_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "9005f3ef53275810d462d4792cd7e412f8fa95482bdf12f9c5e98ba857f476a7"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/mlp/up_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "ef2a8fe512348732555d51ef5e668fa399623bd8f9cd59389a358fab152cc4a9"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/post_attention_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "2defec402158aa4c0b2c46a40e637480543f484b48d25b4a9c2517f6adb38fdc"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/post_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "5af05c890d4af050a8b752187e63796416404855d7f0f89e38c31dddcfd3e8c3"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/pre_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "dbb9eab778b1c9504fd5a1c189e02be9b901dee91ce108f83a0dc5121943e35b"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/self_attn/k_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 856,
+   "sha256": "196c1590df83891269c77d8e3c0f3e04644d5c7d30985bd4990b2056854fbd43"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/self_attn/o_proj_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 4456816,
+   "sha256": "b2c7d656e21b7fff14ee0b4345ef5cea6d8b6cb85cb2e1650674b162726652c9"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/self_attn/q_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 856,
+   "sha256": "5f7bc4231c79615214a55cc24b23ed92fb8f280d8889294a1b9e510159b16c2a"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_1/layer_1/self_attn/wqkv_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "66e21ea442f9449f949a9368e0911f702dfa25d101dde38d83fda7becc36f39d"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/input_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "c740974f83abf0bebe1368963ad09840575b2bdc9ce165abe36954ef932b2855"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/mlp/down_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "ed6a97a6b76c80cf73c0872b54090e3780eb1d708a50b31c5c1aeda5ec59463b"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/mlp/gate_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "349df26d7fe81c44bf157fc9efa6841e553b502355f2bd27695d2441c65d46c0"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/mlp/up_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "7b875ed7cdf3642c1a030aab5354e4cc9d98d6376365040eb8105d7ac9cf0e0e"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/post_attention_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "de6fef7a1e07c44b18eddca38cf33bb5b6751b2400fedc258ec38bc257f3a3b7"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/post_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "77ec76e8b8766904eff7d03a34a950ad842bc8e49faadc5dc81049e17673d5a1"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/pre_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "cc57622fd05943bde0a5fb293f47e37fdf623ae8c546eecc71445a53788b465e"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/self_attn/k_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 856,
+   "sha256": "196c1590df83891269c77d8e3c0f3e04644d5c7d30985bd4990b2056854fbd43"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/self_attn/o_proj_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 4456816,
+   "sha256": "c64c03dffe767aea3cab9f727feceb23aaf26af97b297fb95258ce200a226ab2"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/self_attn/q_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 856,
+   "sha256": "5f7bc4231c79615214a55cc24b23ed92fb8f280d8889294a1b9e510159b16c2a"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_2/layer_2/self_attn/wqkv_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "109e837cd97fac3baff29735a7473d2eb45c68ca0b28a603fd49090e37b82429"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/input_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "4d1a717abb43f630dd58ab5815d07f5534bfdce1a718cd2fd5cf4f807a6739e9"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/mlp/down_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "54fd9c32751b389aa03d242b3a4fc02333d862dbc89eaf3cdeeae9f93cb534c8"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/mlp/gate_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "0061d7ac874d6e2bfe05d179963c706783a7441413f41cdc044bd7b88eba78f0"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/mlp/up_proj.weight_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "3d4275845c162a674c6ecb37b46f336774d3cd71dca3c14beccc23ba30d3dfd6"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/post_attention_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "eefb4511a61815953b3edfe2ca1e2dbe43abf51548e95c6ac4bec8d39e466967"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/post_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "181044afe3caded023ab7b0b40bcab19a7656ec448034a3df8ad9f18758c7fcd"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/pre_feedforward_layernorm/weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 2392,
+   "sha256": "9c99dfec9777e33091fe41333da4376f757bdd40f2130b4330aa3fff9a20a199"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/self_attn/k_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 1368,
+   "sha256": "9ddd85636b12938302c387549428563d6b5509c1e0cd40353bb936fea0a64c07"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/self_attn/o_proj_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8913264,
+   "sha256": "3d7ff783e7d7318244d040d414a7eee4c3485fe437647a1cf507ee39f10ced76"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/self_attn/q_norm.weight_dtype_BFLOAT16_layout_ROW_MAJOR.tensorbin": {
+   "bytes": 1368,
+   "sha256": "4512424c238a7935ee2a53d3b56028773aa1124af78a0b3cd76dbcd832e79f2c"
+  },
+  "tensors/assistant_tensor_cache_bfp8/layer_3/layer_3/self_attn/wqkv_bfp8_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 10027376,
+   "sha256": "e38b05bd4b4dc7eda8178bc223a979f08ac12452bad0ff898e6bc38855a42946"
+  },
+  "tensors/assistant_tensor_cache_bfp8/model_embed_tokens_weight_bfp4_dtype_BFLOAT4_B_layout_TILE.tensorbin": {
+   "bytes": 150995312,
+   "sha256": "fa589583b45be7c4fedda493517bd7150cc356f75632d34f9469daaec28a0b3b"
+  },
+  "tensors/assistant_tensor_cache_bfp8/post_projection_weight_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 4178288,
+   "sha256": "a926c8853869f484c379a9d5b3397488c04905b15d90082ac679ecf7e6466479"
+  },
+  "tensors/assistant_tensor_cache_bfp8/pre_projection_weight_dtype_BFLOAT8_B_layout_TILE.tensorbin": {
+   "bytes": 8356208,
+   "sha256": "ba02924ee433b4f9689d504ddadc0e3247d23972021668dc03bd9e27c17670dc"
+  }
+ },
+ "format": "gemma4-12b-it-assistant-ttnn-drafter-1x1-v1",
+ "source": {
+  "config_sha256": "b6f19209588fcefe41f65b193fad6148446253c470d36e29441ecc5158a54e6d",
+  "fetch_verification": {
+   "files": {
+    ".gitattributes": "ok",
+    "README.md": "ok",
+    "config.json": "ok",
+    "generation_config.json": "ok",
+    "model.safetensors": "ok",
+    "tokenizer.json": "ok",
+    "tokenizer_config.json": "ok"
+   },
+   "repo": "google/gemma-4-12B-it-assistant",
+   "revision": "46d4c6f13f0ac0ad827b915669b8df9b81c64c51"
+  },
+  "model_id": "google/gemma-4-12B-it-assistant",
+  "safetensors_sha256": "3279c173daddd7186e79d652ad94022415736d3a1370625696c898429b06d6df",
+  "source_dir": "/work/hf-assistant"
+ },
+ "target_manifest_sha256": "007d9f3da8d54363a75e8af84cf0c9b762eafd6edf23679de48b08c62d584d55"
+}

gemma-4-12B-it-assistant/generation_config.json

@@ -0,0 +1,14 @@
+{
+  "bos_token_id": 2,
+  "do_sample": true,
+  "eos_token_id": 1,
+  "pad_token_id": 0,
+  "suppress_tokens": [
+    258883,
+    258882
+  ],
+  "temperature": 1.0,
+  "top_k": 64,
+  "top_p": 0.95,
+  "transformers_version": "5.10.0.dev0"
+}

gemma-4-12B-it-assistant/spec_equivalence.json

@@ -0,0 +1,86 @@
+{
+ "draft_len": 5,
+ "drafter_manifest_sha256": "2db4559e6ec51d81a7cd51b003743ca689fed5220d41b6a403b8d6947e1c74b7",
+ "max_new": 320,
+ "prompts_sha256": "12691a871d1878fcd5fd8fdaceacdf412a6300bc38ba3d61413a3cbe0ff76b3c",
+ "reference_metadata_sha256": "b1190856d991324991e0206cdbe0b2a3e5c9ab83351bf9f17cce6361aa6524fa",
+ "runtime_env": {
+  "GEMMA4_FUSE_GELU_MUL": "1",
+  "GEMMA4_VERIFY_SDPA": "batched"
+ },
+ "runtime_identity": {
+  "binaries": {
+   "build/lib/_ttnncpp.so": "72186b132bf7be85bbb6e1b54bf6de125fbd7a557b12711c84efc6d3e2e08f8d",
+   "build/lib/libtt_metal.so": "0497308232f180a0973406e2afd290b9eafa9e310a16b09bf69acc4434eb0e78",
+   "ttnn/ttnn/_ttnn.so": "a6448405abd714d6ba310dbbc409c01842f42017b8c1d6bb1c30503fb194c7b2"
+  },
+  "gemma4_tree": {
+   "__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "config.py": "ca64c3f783bd7135bec21e2c765004f311631539129ad7ab592b8ae15a2474e4",
+   "conftest.py": "5c9425f9367d48a2873dc83ae074bb0cf62fc433a5c8d140cf030930baf4c4ec",
+   "demo/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "demo/text_demo.py": "c95cee077db887fd748b4b32cf30f0751d21d14596cc0243048a4afafce98988",
+   "demo/text_demo_v2.py": "ad4785b8539e4fdeb32583932e6ac6e2d9bb342edb79d153f5d123d9b323a7d0",
+   "tt/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "tt/assistant/__init__.py": "229bb6de453e5f58c9c6bc80368cc417cc943ac0d6a6a268b845e91198ca2aa2",
+   "tt/assistant/model.py": "0e3247c34a359a73bd4c8ecc7365e028372084554eeeba41682d1fd818c296af",
+   "tt/attention/__init__.py": "df24b2bf4311ffaee781692ff8f465dea0f415e2323cf87fba4ce22227edb8ae",
+   "tt/attention/config.py": "01b0f3e14c31aae5ed01104aee7f4cb03913007c0d0018f9d35d341d3fe049ef",
+   "tt/attention/decode.py": "0ec303ff75ded2a03f773c22aba27c719e2f055c71b9560fe18661d0272fd3db",
+   "tt/attention/kv_cache.py": "3a1e9f520cdde61dd49550dbfca1072d009ee34878bafe5923c655821c09bff7",
+   "tt/attention/kv_cache_hybrid.py": "9074a2d1de4b3a65d11271370f1fce39a78e5523b841752bcaa87dccb4b56470",
+   "tt/attention/operations.py": "f5cda2ade4031a66e631a732199f3b4b9a00b45ef2e252aee0d3138406bbcc43",
+   "tt/attention/prefill.py": "32c6e1c9423b9c22f14558c33d76d9164cb8a27c939cb5d1ccb6da039b7c831f",
+   "tt/attention/weights.py": "3ec94d60c6d1085bed0bf83fbc450aa9599a476341d3c6d77466b1b2e17c00d6",
+   "tt/ccl.py": "3580f2e25950381465e55dd2886d2832c33d8d6fc618b5a2b94088d0b1a91105",
+   "tt/common.py": "e4369b067c3c2e7930fb538a34ab04b237940048e771f2f8f0560776f03a578f",
+   "tt/decode_mm.py": "93ebedf2eb3b0c78ebbddfc00c630b13c726d9b13bb07fb53a073a207731bae4",
+   "tt/experts/__init__.py": "567aef533a30a692e4c0b28695c15d13e2cfc024ee621e4147c836b63220d5c3",
+   "tt/experts/config.py": "80bd7d18ffd0e0b6bd969d05a8e9972ff8473dc63631f1cb6de0bd619a50f33b",
+   "tt/experts/decode.py": "112b9df4b88e8395053fdbf69315e3a43e9f3f4877e699ca5a48462ccd8e804b",
+   "tt/experts/operations.py": "27db30001f4280dc46bd500d5d811f56ccd8a0896d4eb9f90a6ef50e9af3355b",
+   "tt/experts/prefill.py": "5f07a86da85d5ba64838e03d6627c7a78ccfcc06ebfbdaff39d8f7b52f84948d",
+   "tt/experts/weights.py": "dda56687ff669a92b8447dc098e4cad6007f94d66b642f1da48c17abd8568916",
+   "tt/gemma4_attention_config.py": "8e892a13f89acadd2415719c7c22d188ee906f5fabb1d326464b65afa06816be",
+   "tt/gemma4_expert_config.py": "e7b1037156bc3f20cacba6e7a59c5456ebaefa3ed772310f7476908b26aaf20a",
+   "tt/generator.py": "34914394ca36e2bc5942b28710ebc7362d7b610c4eb2db33745311b391ceee9e",
+   "tt/generator_trace.py": "d5c303e5fe936bf32d097d4013336dcfc587a3a2502cd71fd266c00ab6e2c9f3",
+   "tt/generator_vllm.py": "e3b9831358e44e6bcc1433e39ea13b82a7c15565826a38a00815a8a7640b65a4",
+   "tt/greedy_decode.py": "a03ac98749300d79ebf8e124b8fd9507df556fc4d518bf46776f7a7df08cf521",
+   "tt/kernels/kv_rows_write.cpp": "af410a5fe3dbeefc873eee2f3eaf5136d368fc8ad616730700519a1d6ce83b6d",
+   "tt/layer.py": "e3261517b9328d460f84dd888f13694bb50047eb70240e6cc1967f16803599e0",
+   "tt/model.py": "2075ea168f8c4fffe90195cadf3ea235bfafdcbaca6daf16081fd05e24106a6c",
+   "tt/model_config.py": "04ecd4a462f1ba726186e2c7fce7c3c86b78faf21091af9c9c098f325bb9556d",
+   "tt/moe.py": "37d5c5921fe9e5dc61f7b788bc0b3dfec349ce17915dc5450cf286a217f64e41",
+   "tt/precision.py": "588e9c3f9864c248175f0c8b2c8b45a5e45511568f71d448cf8ed1621c1d6571",
+   "tt/rms_norm.py": "cf0f9fb6191ae3d94191aa62a81686eeccb46b6c44635a1c75967d803886b213",
+   "tt/router.py": "61cfcfc0f6b3a7899f8d0b0a9de3738d8af933602e30d2fc4550c05ea9b19ff9",
+   "tt/serving_vllm.py": "93f5f00e4fa5a287254d3c7d24b12bccc76aa2e0930fe59f2ab60b47f728c2e4",
+   "tt/shared_mlp.py": "fee9764001ac7587810bbb253d80dc29b8997056a9e35540710b60292314e161",
+   "tt/single_user.py": "e1535718aeaaabb6b26074e66e3bf5a64f39be0e6dc44e17fcc3f70036b4b8df",
+   "tt/spec_decode.py": "8acf4609aca527c123b5d064236d4e817bca7e481702ad6580c0c417a30885e7",
+   "tt/spec_greedy.py": "efc6ef2f6df41b77b79003a1ba213c006b397e6e4c44baa723f81dda4ef3e956",
+   "utils/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "utils/general_utils.py": "df7324ddc31c12d8177ae8ff007a220cb6e298b3ade498205ecaf5e93abe1eb9",
+   "utils/substate.py": "dd0c86aa2b1d6131d45f09ede19690e559543c51dc1166c858277a5c183963ac"
+  }
+ },
+ "scope": "greedy token streams of speculative decoding equal non-speculative greedy decoding on the recorded prompts, same proven runtime",
+ "speculative_metadata_sha256": "8d73468115afbf703356394074e01a74a3cfcacac68650214bb52d19d0a3ed0d",
+ "streams_identical": true,
+ "streams_sha256": {
+  "code": "e81a12880f67e38b9409ceb85846ca731a0cdb9efe4046d458bae25c1be09417",
+  "code-c": "4755648cb1b633a42596b416aeae1d2e4d2519b29188d31d7be9f85a73eb05cc",
+  "code-lru": "2ddfbc830a509221a668dc6f430dd4c7f65d424f0a47ef0297fe9825ce64bcdd",
+  "code-sql": "36484b712be95b98a7fc1b0e06fd2b4a3d4f09017f3a6f791102529d803c37c8",
+  "explain": "c4c3e77a59cab64b75d4604f3dadcd75fa06cbcdfb77c4e6e3209a5f10691332",
+  "logic": "f28d9e2ee05d50b2225c186bfe2fdeb2c5464f5e4809ebe6fc4c70e7a72b62fa",
+  "long-code": "557d5b465ba6ba3b9260b33dd5b7d943c70599b8de06c669be70ec70178b50dd",
+  "long-summary": "f9a898b16dc9eed88e73e18d07c9abb019f937bea73287f1d101dea86272ff6e",
+  "math": "c109ed7a56f25c977d1e0ca80337a40083fe4c8172eed6a2dc8ad081f91244b2",
+  "story": "ded163eb533ec4a7e47cd4351644d35c209852c8418503e060b988ddf6765414"
+ },
+ "target_manifest_sha256": "007d9f3da8d54363a75e8af84cf0c9b762eafd6edf23679de48b08c62d584d55",
+ "target_proof_sha256": "1bd70995c42ce9d484c717d4169a000df36ce5181798c6f54b26138128daf296",
+ "tokens_compared": 3130
+}

gemma-4-12B-it/chat_template.jinja

@@ -0,0 +1,390 @@
+{#
+  Template: Google Gemma 4 Canonical Chat Template
+  Author: Google Gemma Engineering Team
+  Published: 2026-07-09
+  Context: Fixed tool-calling loops, turn closures, and thinking content-ordering.
+#}
+{%- macro format_parameters(properties, required, filter_keys=false) -%}
+    {%- set standard_keys = ['description', 'type', 'properties', 'required', 'nullable'] -%}
+    {%- set ns = namespace(found_first=false) -%}
+    {%- for key, value in properties | dictsort -%}
+        {%- set add_comma = false -%}
+        {%- if not filter_keys or key not in standard_keys -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {{ key }}:{
+            {%- if value['description'] -%}
+                description:<|"|>{{ value['description'] }}<|"|>
+                {%- set add_comma = true -%}
+            {%- endif -%}
+            {%- if value['type'] | upper == 'STRING' -%}
+                {%- if value['enum'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    enum:{{ format_argument(value['enum']) }}
+                {%- endif -%}
+            {%- elif value['type'] | upper == 'ARRAY' -%}
+                {%- if value['items'] is mapping and value['items'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    items:{
+                    {%- set ns_items = namespace(found_first=false) -%}
+                    {%- for item_key, item_value in value['items'] | dictsort -%}
+                        {%- if item_value is not none -%}
+                            {%- if ns_items.found_first %},{% endif -%}
+                            {%- set ns_items.found_first = true -%}
+                            {%- if item_key == 'properties' -%}
+                                properties:{
+                                {%- if item_value is mapping -%}
+                                    {{- format_parameters(item_value, value['items']['required'] | default([])) -}}
+                                {%- endif -%}
+                                }
+                            {%- elif item_key == 'required' -%}
+                                required:[
+                                {%- for req_item in item_value -%}
+                                    <|"|>{{- req_item -}}<|"|>
+                                    {%- if not loop.last %},{% endif -%}
+                                {%- endfor -%}
+                                ]
+                            {%- elif item_key == 'type' -%}
+                                {%- if item_value is string -%}
+                                    type:{{ format_argument(item_value | upper) }}
+                                {%- else -%}
+                                    type:{{ format_argument(item_value | map('upper') | list) }}
+                                {%- endif -%}
+                            {%- else -%}
+                                {{ item_key }}:{{ format_argument(item_value) }}
+                            {%- endif -%}
+                        {%- endif -%}
+                    {%- endfor -%}
+                    }
+                {%- endif -%}
+            {%- endif -%}
+            {%- if value['nullable'] %}
+                {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                nullable:true
+            {%- endif -%}
+            {%- if value['type'] | upper == 'OBJECT' -%}
+                {%- if value['properties'] is defined and value['properties'] is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value['properties'], value['required'] | default([])) -}}
+                    }
+                {%- elif value is mapping -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    properties:{
+                    {{- format_parameters(value, value['required'] | default([]), filter_keys=true) -}}
+                    }
+                {%- endif -%}
+                {%- if value['required'] -%}
+                    {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+                    required:[
+                    {%- for item in value['required'] | default([]) -%}
+                        <|"|>{{- item -}}<|"|>
+                        {%- if not loop.last %},{% endif -%}
+                    {%- endfor -%}
+                    ]
+                {%- endif -%}
+            {%- endif -%}
+            {%- if add_comma %},{%- else -%} {%- set add_comma = true -%} {% endif -%}
+            type:<|"|>{{ value['type'] | upper }}<|"|>}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endmacro -%}
+{%- macro format_function_declaration(tool_data) -%}
+    declaration:{{- tool_data['function']['name'] -}}{description:<|"|>{{- tool_data['function']['description'] -}}<|"|>
+    {%- set params = tool_data['function']['parameters'] -%}
+    {%- if params -%}
+        ,parameters:{
+        {%- if params['properties'] -%}
+            properties:{ {{- format_parameters(params['properties'], params['required']) -}} },
+        {%- endif -%}
+        {%- if params['required'] -%}
+            required:[
+            {%- for item in params['required'] -%}
+                <|"|>{{- item -}}<|"|>
+                {{- ',' if not loop.last -}}
+            {%- endfor -%}
+            ],
+        {%- endif -%}
+        {%- if params['type'] -%}
+            type:<|"|>{{- params['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    {%- if 'response' in tool_data['function'] -%}
+        {%- set response_declaration = tool_data['function']['response'] -%}
+        ,response:{
+        {%- if response_declaration['description'] -%}
+            description:<|"|>{{- response_declaration['description'] -}}<|"|>,
+        {%- endif -%}
+        {%- if response_declaration['type'] | upper == 'OBJECT' -%}
+            type:<|"|>{{- response_declaration['type'] | upper -}}<|"|>}
+        {%- endif -%}
+    {%- endif -%}
+    }
+{%- endmacro -%}
+{%- macro format_argument(argument, escape_keys=True) -%}
+    {%- if argument is none -%}
+        {{- 'null' -}}
+    {%- elif argument is string -%}
+        {{- '<|"|>' + argument + '<|"|>' -}}
+    {%- elif argument is boolean -%}
+        {{- 'true' if argument else 'false' -}}
+    {%- elif argument is mapping -%}
+        {{- '{' -}}
+        {%- set ns = namespace(found_first=false) -%}
+        {%- for key, value in argument | dictsort -%}
+            {%- if ns.found_first %},{% endif -%}
+            {%- set ns.found_first = true -%}
+            {%- if escape_keys -%}
+                {{- '<|"|>' + key + '<|"|>' -}}
+            {%- else -%}
+                {{- key -}}
+            {%- endif -%}
+            :{{- format_argument(value, escape_keys=escape_keys) -}}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- elif argument is sequence -%}
+        {{- '[' -}}
+        {%- for item in argument -%}
+            {{- format_argument(item, escape_keys=escape_keys) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- ']' -}}
+    {%- else -%}
+        {{- argument -}}
+    {%- endif -%}
+{%- endmacro -%}
+{%- macro strip_thinking(text) -%}
+    {%- set ns = namespace(result='') -%}
+    {%- for part in text.split('<channel|>') -%}
+        {%- if '<|channel>' in part -%}
+            {%- set ns.result = ns.result + part.split('<|channel>')[0] -%}
+        {%- else -%}
+            {%- set ns.result = ns.result + part -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {{- ns.result | trim -}}
+{%- endmacro -%}
+
+{%- macro format_tool_response_block(tool_name, response) -%}
+    {{- '<|tool_response>' -}}
+    {%- if response is mapping -%}
+        {{- 'response:' + tool_name + '{' -}}
+        {%- for key, value in response | dictsort -%}
+            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+            {%- if not loop.last %},{% endif -%}
+        {%- endfor -%}
+        {{- '}' -}}
+    {%- else -%}
+        {{- 'response:' + tool_name + '{value:' + format_argument(response, escape_keys=False) + '}' -}}
+    {%- endif -%}
+    {{- '<tool_response|>' -}}
+{%- endmacro -%}
+
+{#- ===== SETUP ===== -#}
+{%- set ns = namespace(prev_message_type=None, prev_non_tool_role=None) -%}
+{%- set loop_messages = messages -%}
+{%- set enable_thinking = enable_thinking | default(false) -%}
+{%- set preserve_thinking = preserve_thinking | default(false) -%}
+{{- bos_token -}}
+{#- Handle System/Tool Definitions Block -#}
+{%- if enable_thinking or tools or (messages and messages[0]['role'] in ['system', 'developer']) -%}
+    {{- '<|turn>system\n' -}}
+    {#- Inject Thinking token at the very top of the FIRST system turn -#}
+    {%- if enable_thinking -%}
+        {{- '<|think|>\n' -}}
+        {%- set ns.prev_message_type = 'think' -%}
+    {%- endif -%}
+    {%- if messages and messages[0]['role'] in ['system', 'developer'] -%}
+        {%- if messages[0]['content'] is string -%}
+            {{- messages[0]['content'] | trim -}}
+        {%- elif messages[0]['content'] is sequence -%}
+            {%- for item in messages[0]['content'] -%}
+                {{- item['text'] | trim + ' '-}}
+            {%- endfor -%}
+        {%- endif -%}
+        {%- set loop_messages = messages[1:] -%}
+    {%- endif -%}
+    {%- if tools -%}
+        {%- for tool in tools %}
+            {{- '<|tool>' -}}
+            {{- format_function_declaration(tool) | trim -}}
+            {{- '<tool|>' -}}
+        {%- endfor %}
+        {%- set ns.prev_message_type = 'tool' -%}
+    {%- endif -%}
+    {{- '<turn|>\n' -}}
+{%- endif %}
+
+{#- Pre-scan: find last user message index for reasoning guard -#}
+{%- set ns_turn = namespace(last_user_idx=-1) -%}
+{%- for i in range(loop_messages | length) -%}
+    {%- if loop_messages[i]['role'] == 'user' -%}
+        {%- set ns_turn.last_user_idx = i -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Loop through messages -#}
+{%- for message in loop_messages -%}
+    {%- if message['role'] != 'tool' -%}
+    {%- set ns.prev_message_type = None -%}
+    {%- set role = 'model' if message['role'] == 'assistant' else message['role'] -%}
+    {#- Detect continuation using tracked state — O(1) instead of O(n) backward scan -#}
+    {%- set continue_same_model_turn = (role == 'model' and ns.prev_non_tool_role == 'assistant') -%}
+    {%- if not continue_same_model_turn -%}
+        {{- '<|turn>' + role + '\n' }}
+
+    {%- endif -%}
+
+    {#- Render reasoning/reasoning_content as thinking channel -#}
+    {%- set thinking_text = message.get('reasoning') or message.get('reasoning_content') -%}
+    {%- set thinking_gate = (loop.index0 > ns_turn.last_user_idx) or (preserve_thinking and message.get('tool_calls')) -%}
+    {%- if thinking_text and thinking_gate -%}
+        {{- '<|channel>thought\n' + thinking_text + '\n<channel|>' -}}
+    {%- endif -%}
+
+            {%- if message.get('tool_calls') -%}
+                {%- for tool_call in message.get('tool_calls') -%}
+                    {%- set function = tool_call['function'] -%}
+                    {{- '<|tool_call>call:' + function['name'] + '{' -}}
+                    {%- if function['arguments'] is mapping -%}
+                        {%- set ns_args = namespace(found_first=false) -%}
+                        {%- for key, value in function['arguments'] | dictsort -%}
+                            {%- if ns_args.found_first %},{% endif -%}
+                            {%- set ns_args.found_first = true -%}
+                            {{- key -}}:{{- format_argument(value, escape_keys=False) -}}
+                        {%- endfor -%}
+                    {%- elif function['arguments'] is none -%}
+                    {%- else -%}
+                        {{- raise_exception(
+                            "chat_template: tool_calls[].function.arguments must be a "
+                            "JSON object (mapping), not a string. Deserialize arguments "
+                            "before passing to the template."
+                        ) -}}
+                    {%- endif -%}
+                    {{- '}<tool_call|>' -}}
+                {%- endfor -%}
+                {%- set ns.prev_message_type = 'tool_call' -%}
+            {%- endif -%}
+
+            {%- set ns_tr_out = namespace(flag=false) -%}
+            {%- if message.get('tool_responses') -%}
+                {#- Legacy: tool_responses embedded on the assistant message (Google/Gemma native) -#}
+                {%- for tool_response in message.get('tool_responses') -%}
+                    {{- format_tool_response_block(tool_response['name'] | default('unknown', true), tool_response['response']) -}}
+                    {%- set ns_tr_out.flag = true -%}
+                    {%- set ns.prev_message_type = 'tool_response' -%}
+                {%- endfor -%}
+            {%- elif message.get('tool_calls') -%}
+                {#- OpenAI Chat Completions: forward-scan consecutive role:tool messages -#}
+                {%- set ns_tool_scan = namespace(stopped=false) -%}
+                {%- for k in range(loop.index0 + 1, loop_messages | length) -%}
+                    {%- if ns_tool_scan.stopped -%}
+                    {%- elif loop_messages[k]['role'] != 'tool' -%}
+                        {%- set ns_tool_scan.stopped = true -%}
+                    {%- else -%}
+                        {%- set follow = loop_messages[k] -%}
+                        {#- Resolve tool_call_id to function name -#}
+                        {%- set ns_tname = namespace(name=follow.get('name') or 'unknown') -%}
+                        {%- for tc in message.get('tool_calls') -%}
+                            {%- if tc.get('id') == follow.get('tool_call_id') -%}
+                                {%- set ns_tname.name = tc['function']['name'] -%}
+                            {%- endif -%}
+                        {%- endfor -%}
+                        {#- Handle content as string or content-parts array -#}
+                        {%- set tool_body = follow.get('content') -%}
+                        {%- if tool_body is string -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- elif tool_body is sequence and tool_body is not string -%}
+                            {%- set ns_txt = namespace(s='') -%}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') == 'text' -%}
+                                    {%- set ns_txt.s = ns_txt.s + (part.get('text') | default('')) -%}
+                                {%- endif -%}
+                            {%- endfor -%}
+                            {{- format_tool_response_block(ns_tname.name, ns_txt.s) -}}
+                            {%- for part in tool_body -%}
+                                {%- if part.get('type') in ['image', 'image_url'] -%}
+                                    {{- '<|image|>' -}}
+                                {%- elif part.get('type') in ['audio', 'input_audio'] -%}
+                                    {{- '<|audio|>' -}}
+                                {%- elif part.get('type') == 'video' -%}
+                                    {{- '<|video|>' -}}
+                                {%- endif -%}
+                            {%- endfor -%}
+                        {%- else -%}
+                            {{- format_tool_response_block(ns_tname.name, tool_body) -}}
+                        {%- endif -%}
+                        {%- set ns_tr_out.flag = true -%}
+                        {%- set ns.prev_message_type = 'tool_response' -%}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+
+            {%- set captured_content -%}
+            {%- if message.get('content') is string -%}
+                {%- if role == 'model' -%}
+                    {{- strip_thinking(message['content']) -}}
+                {%- else -%}
+                    {{- message['content'] | trim -}}
+                {%- endif -%}
+            {%- elif message.get('content') is sequence -%}
+                {%- for item in message['content'] -%}
+                    {%- if item.get('type') == 'text' -%}
+                        {%- if role == 'model' -%}
+                            {{- strip_thinking(item['text']) -}}
+                        {%- else -%}
+                            {{- item['text'] | trim -}}
+                        {%- endif -%}
+                    {%- elif item.get('type') in ['image', 'image_url'] -%}
+                        {{- '<|image|>' -}}
+                    {%- elif item.get('type') in ['audio', 'input_audio'] -%}
+                        {{- '<|audio|>' -}}
+                    {%- elif item.get('type') == 'video' -%}
+                        {{- '<|video|>' -}}
+                    {%- endif -%}
+                {%- endfor -%}
+            {%- endif -%}
+            {%- endset -%}
+
+            {{- captured_content -}}
+            {%- set has_content = captured_content | trim | length > 0 -%}
+
+        {#- Forward-scan: find next non-tool message role for continuation detection -#}
+        {%- set next_nt = namespace(role=None, found=false) -%}
+        {%- for j in range(loop.index0 + 1, loop_messages | length) -%}
+            {%- if not next_nt.found -%}
+                {%- if loop_messages[j]['role'] != 'tool' -%}
+                    {%- set next_nt.role = loop_messages[j]['role'] -%}
+                    {%- set next_nt.found = true -%}
+                {%- endif -%}
+            {%- endif -%}
+        {%- endfor -%}
+
+        {%- set continues_into_next = (
+            role == 'model'
+            and next_nt.role == 'assistant'
+            and (not message.get('tool_calls') or ns_tr_out.flag)
+        ) -%}
+
+        {%- if ns.prev_message_type == 'tool_call' and not ns_tr_out.flag -%}
+            {{- '<|tool_response>' -}}
+        {%- elif continues_into_next -%}
+        {%- elif not (ns_tr_out.flag and not has_content and not next_nt.found) -%}
+            {{- '<turn|>\n' -}}
+        {%- endif -%}
+
+    {#- Track previous non-tool role for next iteration (avoids O(n) backward scan) -#}
+    {%- set ns.prev_non_tool_role = message['role'] -%}
+    {%- endif -%}
+{%- endfor -%}
+
+{%- if add_generation_prompt -%}
+    {%- if ns.prev_message_type != 'tool_response' and ns.prev_message_type != 'tool_call' -%}
+        {{- '<|turn>model\n' -}}
+        {%- if not enable_thinking -%}
+            {{- '<|channel>thought\n<channel|>' -}}
+        {%- endif -%}
+    {%- elif ns.prev_message_type == 'tool_response' and enable_thinking -%}
+        {{- '<|channel>thought\n' -}}
+    {%- endif -%}
+{%- endif -%}

gemma-4-12B-it/config.json

@@ -0,0 +1,172 @@
+{
+  "architectures": [
+    "Gemma4UnifiedForConditionalGeneration"
+  ],
+  "audio_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "audio_embed_dim": 640,
+    "audio_samples_per_token": 640,
+    "chunk_size_feed_forward": 0,
+    "dtype": null,
+    "hidden_size": 640,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "model_type": "gemma4_unified_audio",
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_proj_dims": 640,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06
+  },
+  "audio_token_id": 258881,
+  "boa_token_id": 256000,
+  "boi_token_id": 255999,
+  "dtype": "bfloat16",
+  "eoa_token_index": 258883,
+  "eoi_token_id": 258882,
+  "eos_token_id": [
+    1,
+    106
+  ],
+  "image_token_id": 258880,
+  "initializer_range": 0.02,
+  "model_type": "gemma4_unified",
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attention_k_eq_v": true,
+    "bos_token_id": 2,
+    "enable_moe_block": false,
+    "eos_token_id": 1,
+    "final_logit_softcapping": 30.0,
+    "global_head_dim": 512,
+    "head_dim": 256,
+    "hidden_activation": "gelu_pytorch_tanh",
+    "hidden_size": 3840,
+    "hidden_size_per_layer_input": 0,
+    "initializer_range": 0.02,
+    "intermediate_size": 15360,
+    "layer_types": [
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "sliding_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 262144,
+    "model_type": "gemma4_unified_text",
+    "moe_intermediate_size": null,
+    "num_attention_heads": 16,
+    "num_experts": null,
+    "num_global_key_value_heads": 1,
+    "num_hidden_layers": 48,
+    "num_key_value_heads": 8,
+    "num_kv_shared_layers": 0,
+    "pad_token_id": 0,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "full_attention": {
+        "partial_rotary_factor": 0.25,
+        "rope_theta": 1000000.0,
+        "rope_type": "proportional"
+      },
+      "sliding_attention": {
+        "rope_theta": 10000.0,
+        "rope_type": "default"
+      }
+    },
+    "sliding_window": 1024,
+    "tie_word_embeddings": true,
+    "top_k_experts": null,
+    "use_bidirectional_attention": "vision",
+    "use_cache": true,
+    "use_double_wide_mlp": false,
+    "vocab_size": 262144,
+    "vocab_size_per_layer_input": 262144
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.10.0.dev0",
+  "video_token_id": 258884,
+  "vision_config": {
+    "_name_or_path": "",
+    "architectures": null,
+    "chunk_size_feed_forward": 0,
+    "dtype": null,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "mm_embed_dim": 3840,
+    "mm_posemb_size": 1120,
+    "model_patch_size": 48,
+    "model_type": "gemma4_unified_vision",
+    "num_soft_tokens": 280,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_proj_dims": 3840,
+    "patch_size": 16,
+    "pooling_kernel_size": 3,
+    "problem_type": null,
+    "return_dict": true,
+    "rms_norm_eps": 1e-06
+  }
+}

gemma-4-12B-it/equivalence.json

@@ -0,0 +1,106 @@
+{
+ "baseline_metadata_sha256": "903a232363321fef2ac2ba77417d1c0f7d86ae961136361f99cc614b97930c16",
+ "exact_logits_equal": true,
+ "manifest_sha256": "007d9f3da8d54363a75e8af84cf0c9b762eafd6edf23679de48b08c62d584d55",
+ "precision_plan": {
+  "default": {
+   "attention": "bfp8",
+   "embedding": "bf16",
+   "lm_head": "bfp8",
+   "shared_mlp": "bfp8"
+  }
+ },
+ "records_full_logits": [
+  {
+   "baseline_sha256": "6647144f4034bd40266b61df6a163edbdc9fce4e2a6b032fa2fa6e2c557a8eea",
+   "id": "chat-ultrachat-test-0-1k",
+   "restored_sha256": "6647144f4034bd40266b61df6a163edbdc9fce4e2a6b032fa2fa6e2c557a8eea",
+   "rows": 1023
+  },
+  {
+   "baseline_sha256": "9e24b2a7caa64b2ed24685d514365bdb63c5b6bfcf76a2656e9293562c46c8ad",
+   "id": "code-stdlib-_pydecimal-1k",
+   "restored_sha256": "9e24b2a7caa64b2ed24685d514365bdb63c5b6bfcf76a2656e9293562c46c8ad",
+   "rows": 1023
+  },
+  {
+   "baseline_sha256": "30dbb1527de2dc14ee58de257d088e4de66c89c34de3d15b5511d28605bcd5a1",
+   "id": "long-book-2k",
+   "restored_sha256": "30dbb1527de2dc14ee58de257d088e4de66c89c34de3d15b5511d28605bcd5a1",
+   "rows": 2047
+  }
+ ],
+ "records_nll_argmax_equal": [
+  "chat-ultrachat-test-0-1k",
+  "code-stdlib-_pydecimal-1k",
+  "long-book-2k"
+ ],
+ "restored_metadata_sha256": "673a8647733567367ad5ec14f9a86493dddf1dbf12cb0d892adca329a9c6ed92",
+ "runtime_env": {
+  "GEMMA4_FUSE_GELU_MUL": "1",
+  "GEMMA4_VERIFY_SDPA": "batched"
+ },
+ "runtime_identity": {
+  "binaries": {
+   "build/lib/_ttnncpp.so": "72186b132bf7be85bbb6e1b54bf6de125fbd7a557b12711c84efc6d3e2e08f8d",
+   "build/lib/libtt_metal.so": "0497308232f180a0973406e2afd290b9eafa9e310a16b09bf69acc4434eb0e78",
+   "ttnn/ttnn/_ttnn.so": "a6448405abd714d6ba310dbbc409c01842f42017b8c1d6bb1c30503fb194c7b2"
+  },
+  "gemma4_tree": {
+   "__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "config.py": "ca64c3f783bd7135bec21e2c765004f311631539129ad7ab592b8ae15a2474e4",
+   "conftest.py": "5c9425f9367d48a2873dc83ae074bb0cf62fc433a5c8d140cf030930baf4c4ec",
+   "demo/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "demo/text_demo.py": "c95cee077db887fd748b4b32cf30f0751d21d14596cc0243048a4afafce98988",
+   "demo/text_demo_v2.py": "ad4785b8539e4fdeb32583932e6ac6e2d9bb342edb79d153f5d123d9b323a7d0",
+   "tt/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "tt/assistant/__init__.py": "229bb6de453e5f58c9c6bc80368cc417cc943ac0d6a6a268b845e91198ca2aa2",
+   "tt/assistant/model.py": "0e3247c34a359a73bd4c8ecc7365e028372084554eeeba41682d1fd818c296af",
+   "tt/attention/__init__.py": "df24b2bf4311ffaee781692ff8f465dea0f415e2323cf87fba4ce22227edb8ae",
+   "tt/attention/config.py": "01b0f3e14c31aae5ed01104aee7f4cb03913007c0d0018f9d35d341d3fe049ef",
+   "tt/attention/decode.py": "0ec303ff75ded2a03f773c22aba27c719e2f055c71b9560fe18661d0272fd3db",
+   "tt/attention/kv_cache.py": "3a1e9f520cdde61dd49550dbfca1072d009ee34878bafe5923c655821c09bff7",
+   "tt/attention/kv_cache_hybrid.py": "9074a2d1de4b3a65d11271370f1fce39a78e5523b841752bcaa87dccb4b56470",
+   "tt/attention/operations.py": "f5cda2ade4031a66e631a732199f3b4b9a00b45ef2e252aee0d3138406bbcc43",
+   "tt/attention/prefill.py": "32c6e1c9423b9c22f14558c33d76d9164cb8a27c939cb5d1ccb6da039b7c831f",
+   "tt/attention/weights.py": "3ec94d60c6d1085bed0bf83fbc450aa9599a476341d3c6d77466b1b2e17c00d6",
+   "tt/ccl.py": "3580f2e25950381465e55dd2886d2832c33d8d6fc618b5a2b94088d0b1a91105",
+   "tt/common.py": "e4369b067c3c2e7930fb538a34ab04b237940048e771f2f8f0560776f03a578f",
+   "tt/decode_mm.py": "93ebedf2eb3b0c78ebbddfc00c630b13c726d9b13bb07fb53a073a207731bae4",
+   "tt/experts/__init__.py": "567aef533a30a692e4c0b28695c15d13e2cfc024ee621e4147c836b63220d5c3",
+   "tt/experts/config.py": "80bd7d18ffd0e0b6bd969d05a8e9972ff8473dc63631f1cb6de0bd619a50f33b",
+   "tt/experts/decode.py": "112b9df4b88e8395053fdbf69315e3a43e9f3f4877e699ca5a48462ccd8e804b",
+   "tt/experts/operations.py": "27db30001f4280dc46bd500d5d811f56ccd8a0896d4eb9f90a6ef50e9af3355b",
+   "tt/experts/prefill.py": "5f07a86da85d5ba64838e03d6627c7a78ccfcc06ebfbdaff39d8f7b52f84948d",
+   "tt/experts/weights.py": "dda56687ff669a92b8447dc098e4cad6007f94d66b642f1da48c17abd8568916",
+   "tt/gemma4_attention_config.py": "8e892a13f89acadd2415719c7c22d188ee906f5fabb1d326464b65afa06816be",
+   "tt/gemma4_expert_config.py": "e7b1037156bc3f20cacba6e7a59c5456ebaefa3ed772310f7476908b26aaf20a",
+   "tt/generator.py": "34914394ca36e2bc5942b28710ebc7362d7b610c4eb2db33745311b391ceee9e",
+   "tt/generator_trace.py": "d5c303e5fe936bf32d097d4013336dcfc587a3a2502cd71fd266c00ab6e2c9f3",
+   "tt/generator_vllm.py": "e3b9831358e44e6bcc1433e39ea13b82a7c15565826a38a00815a8a7640b65a4",
+   "tt/greedy_decode.py": "a03ac98749300d79ebf8e124b8fd9507df556fc4d518bf46776f7a7df08cf521",
+   "tt/kernels/kv_rows_write.cpp": "af410a5fe3dbeefc873eee2f3eaf5136d368fc8ad616730700519a1d6ce83b6d",
+   "tt/layer.py": "e3261517b9328d460f84dd888f13694bb50047eb70240e6cc1967f16803599e0",
+   "tt/model.py": "2075ea168f8c4fffe90195cadf3ea235bfafdcbaca6daf16081fd05e24106a6c",
+   "tt/model_config.py": "04ecd4a462f1ba726186e2c7fce7c3c86b78faf21091af9c9c098f325bb9556d",
+   "tt/moe.py": "37d5c5921fe9e5dc61f7b788bc0b3dfec349ce17915dc5450cf286a217f64e41",
+   "tt/precision.py": "588e9c3f9864c248175f0c8b2c8b45a5e45511568f71d448cf8ed1621c1d6571",
+   "tt/rms_norm.py": "cf0f9fb6191ae3d94191aa62a81686eeccb46b6c44635a1c75967d803886b213",
+   "tt/router.py": "61cfcfc0f6b3a7899f8d0b0a9de3738d8af933602e30d2fc4550c05ea9b19ff9",
+   "tt/serving_vllm.py": "93f5f00e4fa5a287254d3c7d24b12bccc76aa2e0930fe59f2ab60b47f728c2e4",
+   "tt/shared_mlp.py": "fee9764001ac7587810bbb253d80dc29b8997056a9e35540710b60292314e161",
+   "tt/single_user.py": "e1535718aeaaabb6b26074e66e3bf5a64f39be0e6dc44e17fcc3f70036b4b8df",
+   "tt/spec_decode.py": "8acf4609aca527c123b5d064236d4e817bca7e481702ad6580c0c417a30885e7",
+   "tt/spec_greedy.py": "efc6ef2f6df41b77b79003a1ba213c006b397e6e4c44baa723f81dda4ef3e956",
+   "utils/__init__.py": "501d5b563ca412fa21db82bf39117b5480ecf99bcaf11996b9c3d5f1093bb9a8",
+   "utils/general_utils.py": "df7324ddc31c12d8177ae8ff007a220cb6e298b3ade498205ecaf5e93abe1eb9",
+   "utils/substate.py": "dd0c86aa2b1d6131d45f09ede19690e559543c51dc1166c858277a5c183963ac"
+  }
+ },
+ "runtime_run_sha256": {
+  "gemma4_tree_sha256": "ffae949a9a260c3a03a9b0a2ef891668bf79fb790df84f53e24e19048e9fe1fb",
+  "tool_sha256": "36485b68752f51c3642e3dd777f5da0cdb9de61ab819d5680f95402e1a24ede3"
+ },
+ "scope": "bit-exact full-vocabulary logits, original weights quantized at load vs native reload, same runtime; not a quality certification",
+ "tokens_compared": 4093
+}

gemma-4-12B-it/generation_config.json

@@ -0,0 +1,18 @@
+{
+  "bos_token_id": 2,
+  "do_sample": true,
+  "eos_token_id": [
+    1,
+    106,
+    50
+  ],
+  "pad_token_id": 0,
+  "suppress_tokens": [
+    258883,
+    258882
+  ],
+  "temperature": 1.0,
+  "top_k": 64,
+  "top_p": 0.95,
+  "transformers_version": "5.10.0.dev0"
+}

gemma-4-12B-it/precision_plan.json

@@ -0,0 +1,8 @@
+{
+ "default": {
+  "attention": "bfp8",
+  "shared_mlp": "bfp8",
+  "lm_head": "bfp8",
+  "embedding": "bf16"
+ }
+}

gemma-4-12B-it/tokenizer_config.json

@@ -0,0 +1,120 @@
+{
+  "audio_token": "<|audio|>",
+  "backend": "tokenizers",
+  "boa_token": "<|audio>",
+  "boi_token": "<|image>",
+  "bos_token": "<bos>",
+  "eoa_token": "<audio|>",
+  "eoc_token": "<channel|>",
+  "eoi_token": "<image|>",
+  "eos_token": "<eos>",
+  "eot_token": "<turn|>",
+  "escape_token": "<|\"|>",
+  "etc_token": "<tool_call|>",
+  "etd_token": "<tool|>",
+  "etr_token": "<tool_response|>",
+  "extra_special_tokens": [
+    "<|video|>"
+  ],
+  "image_token": "<|image|>",
+  "mask_token": "<mask>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "padding_side": "left",
+  "processor_class": "Gemma4UnifiedProcessor",
+  "response_schema": {
+    "properties": {
+      "content": {
+        "type": "string"
+      },
+      "role": {
+        "const": "assistant"
+      },
+      "thinking": {
+        "type": "string"
+      },
+      "tool_calls": {
+        "items": {
+          "properties": {
+            "function": {
+              "properties": {
+                "arguments": {
+                  "additionalProperties": {},
+                  "type": "object",
+                  "x-parser": "gemma4-tool-call"
+                },
+                "name": {
+                  "type": "string"
+                }
+              },
+              "type": "object",
+              "x-regex": "call\\:(?P<name>\\w+)(?P<arguments>\\{.*\\})"
+            },
+            "type": {
+              "const": "function"
+            }
+          },
+          "type": "object"
+        },
+        "type": "array",
+        "x-regex-iterator": "<\\|tool_call>(.*?)<tool_call\\|>"
+      }
+    },
+    "type": "object",
+    "x-regex": "(\\<\\|channel\\>thought\\n(?P<thinking>.*?)\\<channel\\|\\>)?(?P<tool_calls>\\<\\|tool_call\\>.*\\<tool_call\\|\\>)?(?P<content>(?:(?!\\<turn\\|\\>)(?!\\<\\|tool_response\\>).)+)?(?:\\<turn\\|\\>|\\<\\|tool_response\\>)?"
+  },
+  "response_template": {
+    "defaults": {
+      "role": "assistant"
+    },
+    "fields": {
+      "content": {
+        "close": [
+          "<turn|>",
+          "<|tool_response>",
+          "<eos>"
+        ],
+        "content": "text"
+      },
+      "thinking": {
+        "close": "<channel|>",
+        "content": "text",
+        "open": "<|channel>thought\n"
+      },
+      "tool_calls": {
+        "close": "<tool_call|>",
+        "content": "json",
+        "content_args": {
+          "string_delims": [
+            [
+              "<|\"|>",
+              "<|\"|>"
+            ]
+          ],
+          "unquoted_keys": true
+        },
+        "open_pattern": "<\\|tool_call>call:(?P<name>\\w+)",
+        "repeats": true,
+        "transform": {
+          "function": {
+            "arguments": "{content}",
+            "name": "{name}"
+          },
+          "type": "function"
+        }
+      }
+    },
+    "start_anchor": [
+      "<|turn>model\n",
+      "<tool_response|>"
+    ]
+  },
+  "soc_token": "<|channel>",
+  "sot_token": "<|turn>",
+  "stc_token": "<|tool_call>",
+  "std_token": "<|tool>",
+  "str_token": "<|tool_response>",
+  "think_token": "<|think|>",
+  "tokenizer_class": "GemmaTokenizer",
+  "unk_token": "<unk>"
+}

launch.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Download and serve the public, verified Gemma 4 12B TT-native all-BFP8 P150 release.
+
+Requires Python 3.11+, Docker, and an exclusively caller-owned P150 to serve.
+No Hugging Face login, Python ML packages, or original model weights are needed.
+Downloads are anonymous; serving is offline inside the ID-pinned container.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import stat
+import sys
+import subprocess
+import tempfile
+from urllib.error import URLError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+
+MODEL_REPO = "Lottolabs/gemma-4-12B-it-TT-BFP8-P150"
+RELEASE_ID = "p3c-20260930"
+IMAGE_TAG = "lottolabs/gemma4-12b-tt-p150:p3c"
+CHECKPOINT_SUBDIR = "gemma-4-12B-it"
+DRAFTER_SUBDIR = "gemma-4-12B-it-assistant"
+HF_BASE = "https://huggingface.co"
+SHA256 = re.compile(r"[0-9a-f]{64}")
+CHUNK_SIZE = 1024 * 1024
+
+
+def request(url):
+    # urllib does not load HF tokens, netrc credentials, or ML dependencies.
+    return urlopen(Request(url, headers={"User-Agent": "gemma4-12b-native-launch/1"}), timeout=120)
+
+
+def fetch_json(url):
+    with request(url) as response:
+        raw = response.read(16 * CHUNK_SIZE + 1)
+    if len(raw) > 16 * CHUNK_SIZE:
+        raise ValueError("Remote JSON exceeds the 16 MiB metadata limit")
+    value = json.loads(raw)
+    if not isinstance(value, dict):
+        raise ValueError("Expected a JSON object")
+    return value, raw
+
+
+def safe_relative(value):
+    if (not isinstance(value, str) or not value
+            or any(part in ("", ".", "..") for part in value.split("/"))
+            or "\\" in value or ":" in value
+            or any(ord(char) < 32 or ord(char) == 127 for char in value)):
+        raise ValueError(f"Unsafe release path: {value!r}")
+    return value
+
+
+def file_records(value):
+    if not isinstance(value, dict) or not value:
+        raise ValueError("Manifest must contain a nonempty files object")
+    for relative, record in value.items():
+        safe_relative(relative)
+        if (not isinstance(record, dict)
+                or not isinstance(record.get("sha256"), str)
+                or SHA256.fullmatch(record["sha256"]) is None
+                or type(record.get("bytes")) is not int or record["bytes"] < 0):
+            raise ValueError(f"Invalid file checksum/size: {relative}")
+        parts = relative.split("/")
+        if any("/".join(parts[:index]) in value for index in range(1, len(parts))):
+            raise ValueError(f"File/directory collision: {relative}")
+    return value
+
+
+def validate_release(release):
+    if (type(release.get("schema_version")) is not int or release["schema_version"] != 1
+            or release.get("model_repo") != MODEL_REPO
+            or release.get("release_id") != RELEASE_ID
+            or release.get("checkpoint_subdir") != CHECKPOINT_SUBDIR
+            or release.get("drafter_subdir") != DRAFTER_SUBDIR):
+        raise ValueError("Unsupported runtime release identity or schema")
+    image = release.get("image")
+    image_id = release.get("image_id")
+    image_archive = release.get("image_archive")
+    if (image != IMAGE_TAG or not isinstance(image_id, str)
+            or re.fullmatch(r"sha256:[0-9a-f]{64}", image_id) is None
+            or image_archive != "runtime-image.tar.gz"):
+        raise ValueError("Release must identify the checksum-pinned bundled runtime image")
+    files = file_records(release.get("files"))
+    target_manifest = f"{CHECKPOINT_SUBDIR}/native_manifest.json"
+    drafter_manifest = f"{DRAFTER_SUBDIR}/drafter_manifest.json"
+    required = {"serve_native.py", "native_checkpoint.py", target_manifest, f"{CHECKPOINT_SUBDIR}/equivalence.json",
+                drafter_manifest, f"{DRAFTER_SUBDIR}/spec_equivalence.json", image_archive}
+    if not required.issubset(files):
+        raise ValueError("Release is missing the server, native manifests, or equivalence proofs")
+    if "runtime-release.json" in files or "launch.py" in files:
+        raise ValueError("Release inventory must exclude runtime-release.json and launch.py")
+    if (release.get("checkpoint_manifest_sha256") != files[target_manifest]["sha256"]
+            or release.get("drafter_manifest_sha256") != files[drafter_manifest]["sha256"]):
+        raise ValueError("Release manifest checksums do not match its file inventory")
+    return files
+
+
+def ensure_image(image, expected_id, archive):
+    inspect = subprocess.run(
+        ["docker", "image", "inspect", image, "--format", "{{.Id}}"],
+        text=True, capture_output=True)
+    if inspect.returncode != 0 or inspect.stdout.strip() != expected_id:
+        print(f"Loading {archive.name} into Docker", file=sys.stderr, flush=True)
+        loaded = subprocess.run(["docker", "load", "--input", str(archive)], text=True)
+        if loaded.returncode != 0:
+            raise ValueError("Docker could not load the verified runtime image archive")
+        inspect = subprocess.run(
+            ["docker", "image", "inspect", image, "--format", "{{.Id}}"],
+            text=True, capture_output=True)
+    if inspect.returncode != 0 or inspect.stdout.strip() != expected_id:
+        raise ValueError("Loaded runtime image identity does not match runtime-release.json")
+
+
+def cache_path(root, relative, directory=False):
+    """Do not follow pre-existing links or special files within a snapshot."""
+    current = root
+    parts = safe_relative(relative).split("/")
+    for index, part in enumerate(parts):
+        current = current / part
+        if current.is_symlink():
+            raise ValueError(f"Refusing a symlink in the release cache: {current}")
+        if current.exists():
+            mode = current.stat().st_mode
+            expected = stat.S_ISDIR if directory or index < len(parts) - 1 else stat.S_ISREG
+            if not expected(mode):
+                raise ValueError(f"Unexpected cache entry type: {current}")
+    return current
+
+
+def verified(path, record):
+    if not path.is_file() or path.stat().st_size != record["bytes"]:
+        return False
+    with path.open("rb") as source:
+        return hashlib.file_digest(source, "sha256").hexdigest() == record["sha256"]
+
+
+def atomic_write(destination, chunks, record=None):
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(prefix=".download-", dir=destination.parent, delete=False) as target:
+            temporary = Path(target.name)
+            digest = hashlib.sha256()
+            size = 0
+            for chunk in chunks:
+                size += len(chunk)
+                if record is not None and size > record["bytes"]:
+                    raise ValueError(f"Download exceeds expected size: {destination.name}")
+                target.write(chunk)
+                digest.update(chunk)
+            if record is not None and (size != record["bytes"] or digest.hexdigest() != record["sha256"]):
+                raise ValueError(f"Download failed SHA256/size verification: {destination}")
+            target.flush()
+            os.fsync(target.fileno())
+            # The container must be able to read the read-only checkpoint mounts.
+            os.fchmod(target.fileno(), 0o644)
+        os.replace(temporary, destination)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
+def download(snapshot, base_url, relative, record):
+    destination = cache_path(snapshot, relative)
+    if verified(destination, record):
+        return
+    print(f"Downloading {relative} ({record['bytes']:,} bytes)", file=sys.stderr, flush=True)
+    with request(base_url + quote(relative, safe="/")) as response:
+        atomic_write(destination, iter(lambda: response.read(CHUNK_SIZE), b""), record)
+
+
+def covered(snapshot, files, subdir, manifest_name, excluded):
+    """The published inventory must be exactly the manifest's file set plus the manifest and its proof."""
+    manifest = json.loads((snapshot / subdir / manifest_name).read_bytes())
+    if not isinstance(manifest, dict):
+        raise ValueError(f"{subdir}/{manifest_name} must be a JSON object")
+    listed = file_records(manifest.get("files"))
+    for relative, record in listed.items():
+        published = files.get(f"{subdir}/{relative}")
+        if published is None or any(published[key] != record[key] for key in ("sha256", "bytes")):
+            raise ValueError(f"Release inventory does not cover {subdir}: {relative}")
+    extra = {name for name in files if name.startswith(subdir + "/")} - {f"{subdir}/{name}" for name in (*listed, *excluded)}
+    if extra:
+        raise ValueError(f"Release inventory has files outside the {subdir} manifest: {sorted(extra)[:3]}")
+
+
+def independent_kernel_cache(snapshot, kernel_cache):
+    if (kernel_cache == snapshot or kernel_cache.is_relative_to(snapshot)
+            or snapshot.is_relative_to(kernel_cache)):
+        raise ValueError("Kernel cache must be independent of the downloaded release directory")
+    if ":" in str(snapshot) or ":" in str(kernel_cache):
+        raise ValueError("Docker bind-mount paths cannot contain ':'")
+    kernel_cache.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryFile(dir=kernel_cache) as probe:
+        probe.write(b"writable")
+        probe.flush()
+
+
+def parser():
+    cache_home = Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache")
+    result = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""Examples:
+  python3 launch.py --download-only --cache-root /large-disk/gemma4-12b
+  python3 launch.py --cache-root /large-disk/gemma4-12b --print-command
+  python3 launch.py --cache-root /large-disk/gemma4-12b --device-ownership-confirmed
+  python3 launch.py --speculation off --port 8001 --device-ownership-confirmed
+
+--print-command downloads/verifies the release but does not run Docker.
+--download-only downloads/verifies without requiring Docker or device ownership.
+Serving never stops containers, resets the device, or takes ownership for you.
+Stop your other accelerator workloads yourself before confirming ownership.
+The API binds to 127.0.0.1 only. Keep the printed immutable revision to reproduce.
+""")
+    result.add_argument("--cache-root", type=Path, default=cache_home / "gemma4-12b-tt-native",
+                        help="Download/cache root (default: $XDG_CACHE_HOME/gemma4-12b-tt-native or ~/.cache/gemma4-12b-tt-native)")
+    result.add_argument("--kernel-cache", type=Path,
+                        help="Independent writable TT kernel cache (default: CACHE_ROOT/kernel-cache)")
+    result.add_argument("--port", type=int, default=8000, help="Loopback API port (default: 8000)")
+    result.add_argument("--speculation", choices=("on", "off"), default="on",
+                        help="Greedy speculative decoding with the proven assistant drafter, K=5 (default: on)")
+    result.add_argument("--max-model-len", type=int, default=262144,
+                        help="Context limit, 1024–262144 (default: 262144)")
+    result.add_argument("--name", default="gemma4-12b-native-api",
+                        help="Docker container name (default: gemma4-12b-native-api)")
+    result.add_argument("--revision", default="main", help="Public HF branch, tag, or commit (default: main)")
+    result.add_argument("--device-ownership-confirmed", action="store_true",
+                        help="Confirm you exclusively own the P150 and have stopped your other workloads")
+    mode = result.add_mutually_exclusive_group()
+    mode.add_argument("--print-command", action="store_true", help="Download, verify, and print the Docker command without running it")
+    mode.add_argument("--download-only", action="store_true", help="Download and verify the native package without serving")
+    return result
+
+
+def main():
+    cli = parser()
+    args = cli.parse_args()
+    if sys.version_info < (3, 11):
+        cli.error("Python 3.11 or newer is required")
+    if not 1 <= args.port <= 65535 or not 1024 <= args.max_model_len <= 262144:
+        cli.error("Port must be 1–65535 and max-model-len must be 1024–262144")
+    if re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*", args.name) is None:
+        cli.error("Invalid Docker container name")
+    if not args.revision.strip():
+        cli.error("Revision must not be empty")
+    if not (args.print_command or args.download_only or args.device_ownership_confirmed):
+        cli.error("Confirm exclusive P150 ownership with --device-ownership-confirmed, or use --print-command/--download-only")
+    try:
+        info, _ = fetch_json(f"{HF_BASE}/api/models/{MODEL_REPO}/revision/{quote(args.revision, safe='')}")
+        commit = info.get("sha")
+        if not isinstance(commit, str) or re.fullmatch(r"[0-9a-f]{40}", commit) is None:
+            raise ValueError("Hugging Face did not resolve the revision to an immutable commit")
+        base_url = f"{HF_BASE}/{MODEL_REPO}/resolve/{commit}/"
+        release, release_raw = fetch_json(base_url + "runtime-release.json")
+        files = validate_release(release)
+        root = args.cache_root.expanduser().resolve()
+        root.mkdir(parents=True, exist_ok=True)
+        snapshot = cache_path(root, f"snapshots/{commit}", directory=True)
+        snapshot.mkdir(parents=True, exist_ok=True)
+        kernel_cache = (args.kernel_cache.expanduser() if args.kernel_cache else root / "kernel-cache").resolve()
+        independent_kernel_cache(snapshot, kernel_cache)
+        print(f"Revision: {commit}\nImage: {release['image']} ({release['image_id']})"
+              f"\nCheckpoint: {snapshot / CHECKPOINT_SUBDIR}\nDrafter: {snapshot / DRAFTER_SUBDIR}"
+              f"\nKernel cache: {kernel_cache}", file=sys.stderr, flush=True)
+        # Check both native inventories before downloading the multi-gigabyte tensors.
+        for subdir, manifest_name, proof in ((CHECKPOINT_SUBDIR, "native_manifest.json", "equivalence.json"),
+                                             (DRAFTER_SUBDIR, "drafter_manifest.json", "spec_equivalence.json")):
+            relative = f"{subdir}/{manifest_name}"
+            download(snapshot, base_url, relative, files[relative])
+            covered(snapshot, files, subdir, manifest_name, (manifest_name, proof))
+        for relative, record in files.items():
+            download(snapshot, base_url, relative, record)
+        atomic_write(cache_path(snapshot, "runtime-release.json"), (release_raw,))
+        print(f"All {len(files)} release files verified.", file=sys.stderr, flush=True)
+        if args.download_only:
+            return 0
+        ensure_image(release["image"], release["image_id"], snapshot / release["image_archive"])
+        command = [sys.executable, "-B", str(snapshot / "serve_native.py"),
+                   "--cache-root", str(kernel_cache), "--image", release["image"],
+                   "--port", str(args.port), "--name", args.name,
+                   "--max-model-len", str(args.max_model_len)]
+        if args.speculation == "off":
+            command.append("--no-speculation")
+        if args.print_command:
+            command.append("--print-command")
+        if args.device_ownership_confirmed:
+            command.append("--device-ownership-confirmed")
+        os.execv(sys.executable, command)
+    except (OSError, URLError, ValueError) as error:
+        cli.exit(1, f"launch.py: {error}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

native_checkpoint.py

@@ -0,0 +1,476 @@
+#!/usr/bin/env python3
+"""TT-native text-only checkpoint for google/gemma-4-12B-it on one P150 (MeshShape 1x1).
+
+Layout of a checkpoint directory ``<root>`` (its basename must contain "12B" so the
+runtime's per-model policy key resolves, e.g. ``.../gemma-4-12B-it``):
+
+  native_manifest.json   format, source identity, precision plan, every file's sha256/bytes
+  precision_plan.json    the Gemma4Precision plan the tensors were quantized with
+  config.json, tokenizer.json, tokenizer_config.json, chat_template.jinja, generation_config.json
+  small.safetensors      every 1-D text tensor (norm weights, layer scalars), lossless BF16
+  tensors/tensor_cache_bf16/**.tensorbin
+                         the exact TTNN host tensors (TILE bfp8/bfp4/bf16 matrices, row-major
+                         bf16 embedding, norm tiles) that the runtime uploads to DRAM; produced by
+                         the runtime's own ttnn.as_tensor cache writer from the ORIGINAL weights
+  equivalence.json       written only by ``record`` from two real runs (never by hand)
+
+Loading never touches the original HF safetensors: 2-D matrices are passed to the model
+constructor as meta-device placeholders (shape only) and every ttnn.as_tensor call hits its
+.tensorbin file; a missing/corrupt file makes the fallback conversion fail loudly on the meta
+tensor. The loader refuses to serve without an equivalence proof that matches the manifest,
+the runtime source tree and the TTNN binaries.
+
+Subcommands (run inside the TT image):
+  finalize <root> --source <hf dir> --fetch-verification <json>
+      after the builder populated tensors/: write small.safetensors, copy config/tokenizer,
+      hash everything into native_manifest.json.
+  record <root> --baseline <teacher-run dir> --restored <teacher-run dir>
+      compare the two runs' full logits (original weights quantized at load vs native reload,
+      identical code/plan/input) and write equivalence.json iff bit-exact.
+  verify <root>
+      verify hashes + proof + runtime identity (what the loader does).
+
+Speculative-decoding drafter (google/gemma-4-12B-it-assistant) directory ``<droot>``:
+  drafter_manifest.json  source identity (fetch verification, config/safetensors sha256), draft weight
+                         dtype, target checkpoint manifest, every file's sha256/bytes
+  config.json, model.safetensors (hardlink of the sha-verified HF file; small tensors are read from it)
+  tensors/assistant_tensor_cache_<dtype>/**.tensorbin   TTNN drafter tensors written by the runtime
+  spec_equivalence.json  written only by ``spec-record``: greedy streams of a speculative run equal the
+                         non-speculative streams of the same proven target runtime
+  drafter-finalize <droot> --source <hf dir> --target <target root> --dtype bfp8
+  spec-record <droot> --target <root> --reference <generate run> --speculative <generate run>
+"""
+import argparse
+import hashlib
+import json
+import os
+import shutil
+from pathlib import Path
+
+FORMAT = "gemma4-12b-it-ttnn-native-text-1x1-v1"
+MODEL_ID = "google/gemma-4-12B-it"
+MANIFEST = "native_manifest.json"
+PROOF = "equivalence.json"
+DRAFTER_FORMAT = "gemma4-12b-it-assistant-ttnn-drafter-1x1-v1"
+DRAFTER_MANIFEST = "drafter_manifest.json"
+SPEC_PROOF = "spec_equivalence.json"
+META_FILES = ("config.json", "tokenizer.json", "tokenizer_config.json", "chat_template.jinja", "generation_config.json")
+TT_ROOT = Path("/home/container_app_user/tt-metal")
+TREE = TT_ROOT / "models/demos/gemma4"
+BINARIES = ("build/lib/_ttnncpp.so", "build/lib/libtt_metal.so", "ttnn/ttnn/_ttnn.so")
+TEXT_PREFIX = "model.language_model."
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for b in iter(lambda: f.read(1 << 24), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def save_json(path, value):
+    path = Path(path)
+    tmp = path.with_suffix(path.suffix + ".partial")
+    tmp.write_text(json.dumps(value, indent=1, sort_keys=True) + "\n")
+    tmp.replace(path)
+
+
+def validate_config(cfg):
+    t = cfg["text_config"]
+    expected = {
+        "hidden_size": 3840,
+        "num_hidden_layers": 48,
+        "intermediate_size": 15360,
+        "num_attention_heads": 16,
+        "num_key_value_heads": 8,
+        "num_global_key_value_heads": 1,
+        "head_dim": 256,
+        "global_head_dim": 512,
+        "vocab_size": 262144,
+        "sliding_window": 1024,
+        "attention_k_eq_v": True,
+        "final_logit_softcapping": 30.0,
+        "tie_word_embeddings": True,
+        "enable_moe_block": False,
+        "hidden_size_per_layer_input": 0,
+        "num_kv_shared_layers": 0,
+    }
+    if cfg.get("model_type") != "gemma4_unified":
+        raise ValueError("expected gemma4_unified config")
+    for k, v in expected.items():
+        if t.get(k) != v:
+            raise ValueError(f"unsupported config {k}={t.get(k)!r} (expected {v!r})")
+    return t
+
+
+def text_shapes(cfg):
+    """Every text tensor of the source checkpoint (name -> shape)."""
+    t = validate_config(cfg)
+    H, I, V = t["hidden_size"], t["intermediate_size"], t["vocab_size"]
+    shapes = {TEXT_PREFIX + "embed_tokens.weight": [V, H], TEXT_PREFIX + "norm.weight": [H]}
+    for i, lt in enumerate(t["layer_types"]):
+        p = f"{TEXT_PREFIX}layers.{i}."
+        full = lt == "full_attention"
+        hd = t["global_head_dim"] if full else t["head_dim"]
+        nkv = t["num_global_key_value_heads"] if full else t["num_key_value_heads"]
+        shapes.update(
+            {
+                p + "input_layernorm.weight": [H],
+                p + "post_attention_layernorm.weight": [H],
+                p + "pre_feedforward_layernorm.weight": [H],
+                p + "post_feedforward_layernorm.weight": [H],
+                p + "layer_scalar": [1],
+                p + "mlp.gate_proj.weight": [I, H],
+                p + "mlp.up_proj.weight": [I, H],
+                p + "mlp.down_proj.weight": [H, I],
+                p + "self_attn.q_proj.weight": [t["num_attention_heads"] * hd, H],
+                p + "self_attn.k_proj.weight": [nkv * hd, H],
+                p + "self_attn.o_proj.weight": [H, t["num_attention_heads"] * hd],
+                p + "self_attn.q_norm.weight": [hd],
+                p + "self_attn.k_norm.weight": [hd],
+            }
+        )
+        if not full:  # K=V tied on full-attention layers: no v_proj
+            shapes[p + "self_attn.v_proj.weight"] = [nkv * hd, H]
+    return shapes
+
+
+def runtime_identity():
+    files = sorted(p for ext in ("*.py", "*.cpp", "*.hpp") for p in TREE.rglob(ext) if "__pycache__" not in p.parts and "tests" not in p.parts)
+    return {
+        "gemma4_tree": {str(p.relative_to(TREE)): digest(p) for p in files},
+        "binaries": {b: digest(TT_ROOT / b) for b in BINARIES if (TT_ROOT / b).exists()},
+    }
+
+
+def read_manifest(root):
+    root = Path(root)
+    m = json.loads((root / MANIFEST).read_text())
+    if m.get("format") != FORMAT or m.get("scope") != "text-only, MeshShape 1x1 (single P150)":
+        raise ValueError("unsupported native checkpoint format/scope")
+    if m.get("source", {}).get("model_id") != MODEL_ID:
+        raise ValueError("native checkpoint model mismatch")
+    cfg = json.loads((root / "config.json").read_text())
+    shapes = text_shapes(cfg)
+    if m["text_tensor_shapes"] != shapes:
+        raise ValueError("manifest tensor inventory disagrees with config")
+    if json.loads((root / "precision_plan.json").read_text()) != m["precision_plan"]:
+        raise ValueError("precision_plan.json differs from manifest")
+    return m
+
+
+def verify_files(root, m):
+    root = Path(root).resolve()
+    listed = set(m["files"])
+    present = {str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()} - {MANIFEST, PROOF}
+    if present != listed:
+        raise ValueError(f"file set mismatch: extra={sorted(present - listed)[:5]} missing={sorted(listed - present)[:5]}")
+    for name, info in m["files"].items():
+        p = root / name
+        if p.stat().st_size != info["bytes"] or digest(p) != info["sha256"]:
+            raise ValueError(f"hash/size mismatch: {name}")
+
+
+def require_proof(root, m):
+    root = Path(root)
+    proof = json.loads((root / PROOF).read_text())
+    if proof.get("manifest_sha256") != digest(root / MANIFEST):
+        raise ValueError("equivalence proof does not match this manifest")
+    if proof.get("exact_logits_equal") is not True or proof.get("tokens_compared", 0) < 1:
+        raise ValueError("equivalence proof is not an exact-logits proof")
+    if proof.get("precision_plan") != m["precision_plan"]:
+        raise ValueError("equivalence proof precision plan mismatch")
+    return proof
+
+
+# GEMMA4_* variables that select paths / the serving entry point and never change numerics; every other
+# GEMMA4_* variable (matmul accumulation, norms, GELU, ring / prefill chunk, ...) must match the proof.
+# GEMMA4_DRAFT_LEN is checked against the drafter's speculative proof (draft_len) by the serving loader.
+SERVING_SELECTORS = frozenset({"GEMMA4_NATIVE", "GEMMA4_SINGLE_USER", "GEMMA4_ASSISTANT_DIR", "GEMMA4_DRAFT_LEN",
+                               "GEMMA4_TOOLS_DIR"})
+
+
+def prepare_native_runtime(root, allow_unproven=False, verify_hashes=True):
+    """Loader entry: returns (model_path, state_dict, tt_cache_path, identity)."""
+    import torch
+    from safetensors.torch import load_file
+
+    root = Path(root).resolve()
+    m = read_manifest(root)
+    if verify_hashes:
+        verify_files(root, m)
+    identity = {"manifest_sha256": digest(root / MANIFEST), "proof": None}
+    if not allow_unproven:
+        proof = require_proof(root, m)
+        now = runtime_identity()
+        if now != proof["runtime_identity"]:
+            diff = [k for k in now["gemma4_tree"] if proof["runtime_identity"]["gemma4_tree"].get(k) != now["gemma4_tree"][k]]
+            raise ValueError(f"runtime differs from the one the equivalence proof covers: {diff[:8] or 'binaries'}")
+        env_now = {k: v for k, v in os.environ.items()
+                   if k.startswith("GEMMA4_") and k != "GEMMA4_PRECISION_PLAN" and k not in SERVING_SELECTORS}
+        if env_now != proof["runtime_env"]:
+            raise ValueError(f"GEMMA4_* runtime environment {env_now} differs from the proof's {proof['runtime_env']}")
+        identity["proof"] = digest(root / PROOF)
+    small = load_file(str(root / "small.safetensors"))
+    state_dict = {}
+    for name, shape in m["text_tensor_shapes"].items():
+        if len(shape) == 2:
+            state_dict[name] = torch.empty(shape, dtype=torch.bfloat16, device="meta")
+        else:
+            state_dict[name] = small[name]
+    return str(root), state_dict, str(root / "tensors"), identity
+
+
+def finalize(root, source, fetch_verification):
+    import torch
+    from safetensors import safe_open
+    from safetensors.torch import save_file
+
+    root, source = Path(root).resolve(), Path(source).resolve()
+    cfg = json.loads((source / "config.json").read_text())
+    shapes = text_shapes(cfg)
+    for f in META_FILES:
+        shutil.copyfile(source / f, root / f)
+    small = {}
+    with safe_open(str(source / "model.safetensors"), framework="pt") as fh:
+        keys = set(fh.keys())
+        missing = [k for k in shapes if k not in keys]
+        if missing:
+            raise ValueError(f"source lacks text tensors: {missing[:5]}")
+        for name, shape in shapes.items():
+            if list(fh.get_slice(name).get_shape()) != shape:
+                raise ValueError(f"source shape mismatch {name}")
+            if len(shape) != 2:
+                small[name] = fh.get_tensor(name).to(torch.bfloat16).contiguous()
+    save_file(small, str(root / "small.safetensors"))
+    tensor_files = sorted(p for p in (root / "tensors").rglob("*.tensorbin"))
+    if not tensor_files:
+        raise ValueError("builder produced no tensors")
+    files = {}
+    for p in sorted(q for q in root.rglob("*") if q.is_file()):
+        rel = str(p.relative_to(root))
+        if rel in (MANIFEST, PROOF):
+            continue
+        files[rel] = {"bytes": p.stat().st_size, "sha256": digest(p)}
+    fv = json.loads(Path(fetch_verification).read_text())
+    manifest = {
+        "format": FORMAT,
+        "scope": "text-only, MeshShape 1x1 (single P150)",
+        "source": {
+            "model_id": MODEL_ID,
+            "fetch_verification": fv,
+            "source_dir": str(source),
+            "config_sha256": digest(source / "config.json"),
+        },
+        "precision_plan": json.loads((root / "precision_plan.json").read_text()),
+        "text_tensor_shapes": shapes,
+        "tensor_files": len(tensor_files),
+        "tensor_bytes": sum(p.stat().st_size for p in tensor_files),
+        "files": files,
+        "builder_runtime_identity": runtime_identity(),
+    }
+    save_json(root / MANIFEST, manifest)
+    return {"files": len(files), "tensor_files": len(tensor_files), "tensor_GB": manifest["tensor_bytes"] / 1e9}
+
+
+def record(root, baseline, restored):
+    import numpy as np
+
+    root, baseline, restored = Path(root).resolve(), Path(baseline), Path(restored)
+    m = read_manifest(root)
+    verify_files(root, m)
+    a = json.loads((baseline / "metadata.json").read_text())
+    b = json.loads((restored / "metadata.json").read_text())
+    for meta in (a, b):
+        if meta.get("status") != "complete" or meta.get("mode") != "teacher" or not meta.get("saved_logits"):
+            raise ValueError("both runs must be completed teacher runs with saved full logits")
+    for key in ("input_sha256", "records", "saved_logits"):
+        if a[key] != b[key]:
+            raise ValueError(f"run configuration mismatch: {key}")
+    if a["runtime"] != b["runtime"]:
+        raise ValueError("runtime (source tree/tool/env/plan) differs between the two runs")
+    if a["runtime"]["precision_plan"] != m["precision_plan"]:
+        raise ValueError("baseline plan differs from the checkpoint plan")
+    if a["weights"]["native"] or not a["weights"]["model_dir"]:
+        raise ValueError("baseline must load the original HF weights")
+    if Path(a["weights"]["cache"]).resolve() == (root / "tensors").resolve():
+        raise ValueError("baseline must quantize from the original weights, not reuse the checkpoint tensors")
+    if not b["weights"]["native"] or b["native_identity"].get("manifest_sha256") != digest(root / MANIFEST):
+        raise ValueError("restored run is not bound to this native checkpoint")
+    tokens, recs = 0, []
+    for rid in a["saved_logits"]:
+        x = np.load(baseline / f"{rid}.logits.npy", mmap_mode="r")
+        y = np.load(restored / f"{rid}.logits.npy", mmap_mode="r")
+        if x.shape != y.shape or x.shape[1] != 262144:
+            raise ValueError(f"logit shape mismatch for {rid}")
+        for s in range(0, x.shape[0], 64):
+            if not np.array_equal(np.asarray(x[s : s + 64]), np.asarray(y[s : s + 64])):
+                raise ValueError(f"native reload logits differ for {rid} at row {s}")
+        tokens += x.shape[0]
+        recs.append(
+            {
+                "id": rid,
+                "rows": int(x.shape[0]),
+                "baseline_sha256": digest(baseline / f"{rid}.logits.npy"),
+                "restored_sha256": digest(restored / f"{rid}.logits.npy"),
+            }
+        )
+    for rid in a["records"]:
+        za, zb = np.load(baseline / f"{rid}.npz"), np.load(restored / f"{rid}.npz")
+        if not (np.array_equal(za["nll"], zb["nll"]) and np.array_equal(za["argmax"], zb["argmax"])):
+            raise ValueError(f"teacher-forced NLL/argmax differ for {rid}")
+    proof = {
+        "manifest_sha256": digest(root / MANIFEST),
+        "exact_logits_equal": True,
+        "tokens_compared": tokens,
+        "records_full_logits": recs,
+        "records_nll_argmax_equal": a["records"],
+        "precision_plan": m["precision_plan"],
+        "runtime_identity": runtime_identity(),
+        "runtime_run_sha256": {"gemma4_tree_sha256": a["runtime"]["gemma4_tree_sha256"], "tool_sha256": a["runtime"]["tool_sha256"]},
+        "runtime_env": a["runtime"]["env"],
+        "baseline_metadata_sha256": digest(baseline / "metadata.json"),
+        "restored_metadata_sha256": digest(restored / "metadata.json"),
+        "scope": "bit-exact full-vocabulary logits, original weights quantized at load vs native reload, same runtime; not a quality certification",
+    }
+    save_json(root / PROOF, proof)
+    return {k: proof[k] for k in ("exact_logits_equal", "tokens_compared", "manifest_sha256")}
+
+
+def _drafter_files(droot):
+    return {
+        str(p.relative_to(droot)): {"bytes": p.stat().st_size, "sha256": digest(p)}
+        for p in sorted(q for q in droot.rglob("*") if q.is_file())
+        if str(p.relative_to(droot)) not in (DRAFTER_MANIFEST, SPEC_PROOF)
+    }
+
+
+def drafter_finalize(droot, source, target, dtype):
+    droot, source, target = Path(droot).resolve(), Path(source).resolve(), Path(target).resolve()
+    fv = json.loads((source / "fetch-verification.json").read_text())
+    if not list((droot / "tensors").rglob("*.tensorbin")):
+        raise ValueError("drafter tensors/ is empty: run the runtime once with --assistant-cache <droot>/tensors")
+    for name in ("config.json", "model.safetensors"):
+        if digest(droot / name) != digest(source / name):
+            raise ValueError(f"{name} differs from the source")
+    manifest = {
+        "format": DRAFTER_FORMAT,
+        "source": {"model_id": "google/gemma-4-12B-it-assistant", "fetch_verification": fv, "source_dir": str(source),
+                   "config_sha256": digest(source / "config.json"), "safetensors_sha256": digest(source / "model.safetensors")},
+        "dtype": dtype,
+        "target_manifest_sha256": digest(target / MANIFEST),
+        "files": _drafter_files(droot),
+        "builder_runtime_identity": runtime_identity(),
+    }
+    save_json(droot / DRAFTER_MANIFEST, manifest)
+    return {"files": len(manifest["files"]), "dtype": dtype}
+
+
+def prepare_drafter(droot, target_identity, allow_unproven=False):
+    """Loader entry for the drafter: verify files (+ speculative proof); returns (dir, cache path, identity)."""
+    droot = Path(droot).resolve()
+    m = json.loads((droot / DRAFTER_MANIFEST).read_text())
+    if m.get("format") != DRAFTER_FORMAT:
+        raise ValueError("unsupported drafter format")
+    if _drafter_files(droot) != m["files"]:
+        raise ValueError("drafter file set / hash mismatch")
+    if target_identity.get("manifest_sha256") != m["target_manifest_sha256"]:
+        raise ValueError("drafter was built for a different target checkpoint")
+    identity = {"drafter_manifest_sha256": digest(droot / DRAFTER_MANIFEST), "spec_proof": None, "dtype": m["dtype"]}
+    if not allow_unproven:
+        proof = json.loads((droot / SPEC_PROOF).read_text())
+        if proof.get("drafter_manifest_sha256") != identity["drafter_manifest_sha256"] or proof.get("streams_identical") is not True:
+            raise ValueError("speculative proof does not cover this drafter")
+        if proof.get("target_proof_sha256") != target_identity.get("proof"):
+            raise ValueError("speculative proof was made against a different target proof")
+        if proof["runtime_identity"] != runtime_identity():
+            raise ValueError("runtime differs from the one the speculative proof covers")
+        identity["spec_proof"] = digest(droot / SPEC_PROOF)
+        identity["draft_len"] = proof["draft_len"]
+    return str(droot), str(droot / "tensors"), identity
+
+
+def spec_record(droot, target, reference, speculative):
+    droot, target = Path(droot).resolve(), Path(target).resolve()
+    a = json.loads((Path(reference) / "metadata.json").read_text())
+    b = json.loads((Path(speculative) / "metadata.json").read_text())
+    for meta in (a, b):
+        if meta.get("status") != "complete" or meta.get("mode") != "generate":
+            raise ValueError("both runs must be completed generate runs")
+        ident = meta.get("native_identity") or {}
+        if ident.get("manifest_sha256") != digest(target / MANIFEST) or not ident.get("proof"):
+            raise ValueError("runs must load the proven target checkpoint (no --allow-unproven)")
+    if a["runtime"] != b["runtime"] or a["native_identity"] != b["native_identity"]:
+        raise ValueError("reference and speculative runs differ in runtime / target identity")
+    if a.get("spec") or not b.get("spec"):
+        raise ValueError("reference must be non-speculative and the second run speculative")
+    if b["spec"]["drafter"]["drafter_manifest_sha256"] != digest(droot / DRAFTER_MANIFEST):
+        raise ValueError("speculative run did not use this drafter")
+    if a["prompts_sha256"] != b["prompts_sha256"] or a["max_new"] != b["max_new"]:
+        raise ValueError("runs used different prompts / lengths")
+    ra = {r["id"]: r["gen_ids"] for r in map(json.loads, open(Path(reference) / "generations.jsonl"))}
+    rb = {r["id"]: r["gen_ids"] for r in map(json.loads, open(Path(speculative) / "generations.jsonl"))}
+    if ra.keys() != rb.keys() or any(ra[k] != rb[k] for k in ra):
+        raise ValueError("speculative greedy streams differ from the non-speculative ones")
+    proof = {
+        "drafter_manifest_sha256": digest(droot / DRAFTER_MANIFEST),
+        "target_manifest_sha256": digest(target / MANIFEST),
+        "target_proof_sha256": a["native_identity"]["proof"],
+        "streams_identical": True,
+        "prompts_sha256": a["prompts_sha256"],
+        "max_new": a["max_new"],
+        "draft_len": b["spec"]["draft_len"],
+        "tokens_compared": sum(len(v) for v in ra.values()),
+        "streams_sha256": {k: hashlib.sha256(json.dumps(v).encode()).hexdigest() for k, v in sorted(ra.items())},
+        "runtime_identity": runtime_identity(),
+        "runtime_env": a["runtime"]["env"],
+        "reference_metadata_sha256": digest(Path(reference) / "metadata.json"),
+        "speculative_metadata_sha256": digest(Path(speculative) / "metadata.json"),
+        "scope": "greedy token streams of speculative decoding equal non-speculative greedy decoding on the recorded prompts, same proven runtime",
+    }
+    save_json(droot / SPEC_PROOF, proof)
+    return {k: proof[k] for k in ("streams_identical", "tokens_compared", "draft_len")}
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    f = sub.add_parser("finalize")
+    f.add_argument("root")
+    f.add_argument("--source", required=True)
+    f.add_argument("--fetch-verification", required=True)
+    r = sub.add_parser("record")
+    r.add_argument("root")
+    r.add_argument("--baseline", required=True)
+    r.add_argument("--restored", required=True)
+    v = sub.add_parser("verify")
+    v.add_argument("root")
+    df = sub.add_parser("drafter-finalize")
+    df.add_argument("root")
+    df.add_argument("--source", required=True)
+    df.add_argument("--target", required=True)
+    df.add_argument("--dtype", default="bfp8")
+    sr = sub.add_parser("spec-record")
+    sr.add_argument("root")
+    sr.add_argument("--target", required=True)
+    sr.add_argument("--reference", required=True)
+    sr.add_argument("--speculative", required=True)
+    a = ap.parse_args()
+    if a.cmd == "drafter-finalize":
+        print(json.dumps(drafter_finalize(a.root, a.source, a.target, a.dtype), indent=1))
+        return
+    if a.cmd == "spec-record":
+        print(json.dumps(spec_record(a.root, a.target, a.reference, a.speculative), indent=1))
+        return
+    if a.cmd == "finalize":
+        print(json.dumps(finalize(a.root, a.source, a.fetch_verification), indent=1))
+    elif a.cmd == "record":
+        print(json.dumps(record(a.root, a.baseline, a.restored), indent=1))
+    else:
+        _, sd, cache, ident = prepare_native_runtime(a.root)
+        print(json.dumps({"verified": True, "tensors": len(sd), "cache": cache, "identity": ident}, indent=1))
+
+
+if __name__ == "__main__":
+    main()

provenance/build_native_checkpoint.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Build a Gemma-4-12B TT-native checkpoint from the ORIGINAL HF weights.
+
+  build_native_checkpoint.py --source <hf model dir named gemma-4-12B-it> --plan <plan.json>
+                             --fetch-verification <fetch-verification.json> --out <root>/gemma-4-12B-it
+
+The runtime's own weight path (create_tt_model -> ttnn.as_tensor) quantizes every tensor
+per the plan and serializes the exact host TTNN tensors into <out>/tensors; then
+native_checkpoint.finalize writes the lossless small tensors, metadata and manifest.
+Needs the device (model construction uploads to DRAM). No proof is written here: run the
+proof recipe (prove_native.sh) afterwards.
+"""
+import argparse
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import native_checkpoint as nc  # noqa: E402
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--source", required=True)
+    ap.add_argument("--plan", required=True)
+    ap.add_argument("--fetch-verification", required=True)
+    ap.add_argument("--out", required=True)
+    a = ap.parse_args()
+    out = Path(a.out)
+    if "12b" not in out.name.lower():
+        raise SystemExit("checkpoint dir basename must contain 12B (runtime policy key)")
+    if out.exists():
+        raise SystemExit(f"{out} exists; refusing to overwrite")
+    (out / "tensors").mkdir(parents=True)
+    shutil.copyfile(a.plan, out / "precision_plan.json")
+    os.environ["TT_CACHE_PATH"] = str(out / "tensors")
+    os.environ["GEMMA4_PRECISION_PLAN"] = str(out / "precision_plan.json")
+
+    import ttnn
+    from models.demos.gemma4.tt.common import create_tt_model
+
+    mesh = ttnn.open_mesh_device(mesh_shape=ttnn.MeshShape(1, 1))
+    try:
+        create_tt_model(mesh_device=mesh, max_batch_size=1, max_seq_len=2048, model_path=a.source, create_kv_cache=False)
+    finally:
+        ttnn.close_mesh_device(mesh)
+    print(json.dumps(nc.finalize(out, a.source, a.fetch_verification), indent=1))
+    print("BUILD_DONE")
+
+
+if __name__ == "__main__":
+    main()

reproduction.json

@@ -0,0 +1,65 @@
+{
+ "schema_version": 1,
+ "release_id": "p3c-20260930",
+ "model_repo": "Lottolabs/gemma-4-12B-it-TT-BFP8-P150",
+ "source_model": {
+  "model_id": "google/gemma-4-12B-it",
+  "revision": "707f0a3b8a3c7ad586ed01e27eafbad8a27dd0f7"
+ },
+ "source_drafter": {
+  "model_id": "google/gemma-4-12B-it-assistant",
+  "revision": "46d4c6f13f0ac0ad827b915669b8df9b81c64c51"
+ },
+ "runtime_image_tag": "lottolabs/gemma4-12b-tt-p150:p3c",
+ "runtime_image": "sha256:53428e7f60a705b75b51b5166f44a912b19c3032981013fb788dd1ce9757aa73",
+ "runtime_source": "runtime/source.json",
+ "checkpoint_build": {
+  "builder": "provenance/build_native_checkpoint.py",
+  "manifest_tool": "native_checkpoint.py",
+  "note": "Tensors are the runtime's own ttnn.as_tensor host tensors written from the original BF16 weights with precision_plan.json (all matrices bfloat8_b, embedding bf16)."
+ },
+ "serve": [
+  "python3",
+  "launch.py",
+  "--cache-root",
+  "/large-disk/gemma4-12b-tt-native",
+  "--device-ownership-confirmed"
+ ],
+ "non_speculative": [
+  "python3",
+  "launch.py",
+  "--cache-root",
+  "/large-disk/gemma4-12b-tt-native",
+  "--speculation",
+  "off",
+  "--device-ownership-confirmed"
+ ],
+ "serving_policy": {
+  "max_num_seqs": 1,
+  "max_model_len": 262144,
+  "block_size": 64,
+  "prefill_chunk_tokens": 16384,
+  "prefix_caching": false,
+  "sliding_kv_ring_tokens": 18432,
+  "speculative": {
+   "method": "gemma4_assistant",
+   "num_speculative_tokens": 5,
+   "applies_to": "greedy (temperature 0) requests"
+  }
+ },
+ "proofs": {
+  "target": "gemma-4-12B-it/equivalence.json",
+  "drafter": "gemma-4-12B-it-assistant/spec_equivalence.json"
+ },
+ "evidence": {
+  "quality": "evidence/quality/",
+  "http": "evidence/http-p3c/",
+  "localmaxxing": "evidence/localmaxxing/speed-test.json",
+  "public_download": "evidence/public-download-verification.json",
+  "public_serving": "evidence/public-serving-smoke.json"
+ },
+ "runtime_distribution": {
+  "path": "runtime-image.tar.gz",
+  "contract": "launch.py verifies the archive checksum, loads it with Docker, and requires the exact recorded image ID."
+ }
+}

runtime/Dockerfile.fast1

@@ -0,0 +1,7 @@
+FROM gemma4-12b:p2c
+USER root
+COPY --chown=1000:1000 gemma4/ /home/container_app_user/tt-metal/models/demos/gemma4/
+COPY --chown=1000:1000 tools/ /home/container_app_user/gemma4-tools/
+ENV GEMMA4_VERIFY_SDPA=batched
+ENV GEMMA4_FUSE_GELU_MUL=1
+USER container_app_user

runtime/Dockerfile.p2b

@@ -0,0 +1,14 @@
+FROM ghcr.io/tenstorrent/tt-inference-server/vllm-tt-metal-src-release-ubuntu-22.04-amd64:0.20.0-de59f8a-03fa3af
+USER root
+COPY --chown=1000:1000 ttnn/ /home/container_app_user/tt-metal/ttnn/
+USER container_app_user
+WORKDIR /home/container_app_user/tt-metal
+RUN cmake --build build_Release --target ttnn --parallel 24 \
+    && cp build_Release/ttnn/_ttnncpp.so build/lib/_ttnncpp.so \
+    && cp build_Release/ttnn/_ttnn.so build/lib/_ttnn.so \
+    && cp build_Release/ttnn/_ttnn.so ttnn/ttnn/_ttnn.so
+USER root
+WORKDIR /home/container_app_user/app/src
+COPY --chown=1000:1000 gemma4/ /home/container_app_user/tt-metal/models/demos/gemma4/
+COPY --chown=1000:1000 tools/ /home/container_app_user/gemma4-tools/
+USER container_app_user

runtime/Dockerfile.p2c

@@ -0,0 +1,6 @@
+FROM gemma4-12b:p2b
+USER root
+
+COPY --chown=1000:1000 gemma4/ /home/container_app_user/tt-metal/models/demos/gemma4/
+COPY --chown=1000:1000 tools/ /home/container_app_user/gemma4-tools/
+USER container_app_user

runtime/Dockerfile.p3c

@@ -0,0 +1,7 @@
+FROM gemma4-12b:fast1
+USER root
+
+COPY --chown=1000:1000 gemma4/ /home/container_app_user/tt-metal/models/demos/gemma4/
+COPY --chown=1000:1000 tools/ /home/container_app_user/gemma4-tools/
+COPY --chown=1000:1000 serving-overlay/ /
+USER container_app_user

runtime/build.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Build the phase-2 runtime image gemma4-12b:<tag>: upstream TT image + this gemma4 tree (Python + JIT
+# kernel sources) + the runner tools. With TTNN_OVERLAY=1 (p2b on) the TTNN sources under ttnn/overlay
+# (in0-multicast 1D matmul factory + in1 reader kernel) are copied into the tree and the TTNN host
+# libraries are rebuilt inside the image (incremental, ~1 min).
+# BASE_IMAGE=<image> builds on a previous image (e.g. gemma4-12b:p2b to reuse its TTNN build).
+# SERVING_OVERLAY=1 (p3 on) also copies serving/overlay/ (vLLM core + TT plugin files for the single-user
+# gemma-4 server: speculative method gemma4_assistant, multi-token stop handling) over the image root.
+# Usage: [TTNN_OVERLAY=1] [SERVING_OVERLAY=1] [BASE_IMAGE=...] build.sh TAG
+set -euo pipefail
+TAG=${1:?tag}
+W=/var/tmp/gemma4-12b
+BASE=${BASE_IMAGE:-ghcr.io/tenstorrent/tt-inference-server/vllm-tt-metal-src-release-ubuntu-22.04-amd64:0.20.0-de59f8a-03fa3af}
+B=$W/build/$TAG
+rm -rf "$B" && mkdir -p "$B/tools"
+rsync -a --exclude __pycache__ --exclude .git --exclude .gitignore "$W/src/gemma4/" "$B/gemma4/"
+cp "$W/tools/tt_eval.py" "$W/tools/native_checkpoint.py" "$W/tools/compare_gen.py" "$B/tools/"
+SERVING_STEP=""
+if [ "${SERVING_OVERLAY:-0}" = 1 ]; then
+  rsync -a --exclude __pycache__ "$W/serving/overlay/" "$B/serving-overlay/"
+  SERVING_STEP='COPY --chown=1000:1000 serving-overlay/ /'
+fi
+TTNN_STEP=""
+if [ "${TTNN_OVERLAY:-0}" = 1 ]; then
+  rsync -a --exclude .git "$W/ttnn/overlay/ttnn/" "$B/ttnn/"
+  TTNN_STEP='COPY --chown=1000:1000 ttnn/ /home/container_app_user/tt-metal/ttnn/
+USER container_app_user
+WORKDIR /home/container_app_user/tt-metal
+RUN cmake --build build_Release --target ttnn --parallel 24 \
+    && cp build_Release/ttnn/_ttnncpp.so build/lib/_ttnncpp.so \
+    && cp build_Release/ttnn/_ttnn.so build/lib/_ttnn.so \
+    && cp build_Release/ttnn/_ttnn.so ttnn/ttnn/_ttnn.so
+USER root
+WORKDIR /home/container_app_user/app/src'
+fi
+cat > "$B/Dockerfile" <<D
+FROM $BASE
+USER root
+$TTNN_STEP
+COPY --chown=1000:1000 gemma4/ /home/container_app_user/tt-metal/models/demos/gemma4/
+COPY --chown=1000:1000 tools/ /home/container_app_user/gemma4-tools/
+$SERVING_STEP
+USER container_app_user
+D
+docker build -q -t "gemma4-12b:$TAG" "$B"
+docker image inspect "gemma4-12b:$TAG" --format '{{.Id}}'

runtime/source.json

@@ -0,0 +1,59 @@
+{
+ "schema_version": 1,
+ "runtime_image": "sha256:53428e7f60a705b75b51b5166f44a912b19c3032981013fb788dd1ce9757aa73",
+ "runtime_image_tag": "lottolabs/gemma4-12b-tt-p150:p3c",
+ "gemma4_tree": {
+  "path": "runtime/gemma4/",
+  "installed_at": "/home/container_app_user/tt-metal/models/demos/gemma4/",
+  "git_branch": "master",
+  "git_commit": "ce67960382fffed8550b38717cedf574e821da06",
+  "note": "Byte-identical to the tree in the runtime image (compared file by file against the image); .git and __pycache__ excluded."
+ },
+ "tools": {
+  "path": "runtime/tools/",
+  "installed_at": "/home/container_app_user/gemma4-tools/"
+ },
+ "serving_overlay": {
+  "path": "runtime/serving-overlay/",
+  "installed_at": "/",
+  "content": "vLLM core and vllm-tt-plugin files for the single-user Gemma 4 server (speculative method gemma4_assistant, multi-token stop handling)"
+ },
+ "ttnn_overlay": {
+  "path": "runtime/ttnn-overlay/",
+  "installed_at": "/home/container_app_user/tt-metal/ttnn/",
+  "content": "in0-multicast 1D matmul program factory; TTNN host libraries rebuilt in layer p2b"
+ },
+ "build_chain": [
+  {
+   "layer": "base",
+   "image": "ghcr.io/tenstorrent/tt-inference-server/vllm-tt-metal-src-release-ubuntu-22.04-amd64:0.20.0-de59f8a-03fa3af",
+   "image_id": "sha256:710de20012a5417ec632e9d1db33b45f81fa9d9961da882a94868d15c5f99735"
+  },
+  {
+   "layer": "p2b",
+   "dockerfile": "runtime/Dockerfile.p2b",
+   "image_id": "sha256:9fc0b344293da678ef107d570753fea90205968a9cced44ec81831f10163cb3b"
+  },
+  {
+   "layer": "p2c",
+   "dockerfile": "runtime/Dockerfile.p2c",
+   "image_id": "sha256:b91c7e92ec16c507c916229ba7d675093379fe18ab05c18732eedcd3b91156f2"
+  },
+  {
+   "layer": "fast1",
+   "dockerfile": "runtime/Dockerfile.fast1",
+   "image_id": "sha256:aade01a9328d028c1979070df60aa17ade1ce729e936c74815b67802a086fff9"
+  },
+  {
+   "layer": "p3c",
+   "dockerfile": "runtime/Dockerfile.p3c",
+   "image_id": "sha256:53428e7f60a705b75b51b5166f44a912b19c3032981013fb788dd1ce9757aa73"
+  }
+ ],
+ "build_script": "runtime/build.sh",
+ "rebuild_note": "Provenance only: intermediate layers copied earlier gemma4 trees that the p3c layer overwrites; the Dockerfiles reference local intermediate tags. Serve the checksum-pinned runtime-image.tar.gz.",
+ "licenses": {
+  "tt-metal": "runtime/licenses/tt-metal/",
+  "vllm": "runtime/licenses/vllm/"
+ }
+}

serve_native.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Serve the TT-native all-BFP8 google/gemma-4-12B-it release (text) on one Tenstorrent P150 through
+vLLM (TT plugin) at its native 262,144-token context, single user, with exact greedy speculative decoding.
+
+Normally invoked by launch.py from a verified snapshot. Before launching it verifies, from this release
+directory: the native checkpoint (manifest, every file hash, exact-logits equivalence proof bound to the
+manifest), the drafter (manifest, hashes, speculative-equivalence proof bound to the target proof and
+draft length) and the runtime image ID pinned in runtime-release.json. Inside the container the loader
+re-verifies the checkpoint and both proofs against the image's runtime identity before loading.
+
+Serving policy (models/demos/gemma4/tt/serving_vllm.py): max_num_seqs 1, block 64, chunked prefill in
+16,384-token chunks, prefix caching off, sliding-window KV as 18,432-token rings, full-attention KV
+paged through vLLM's block table. Greedy requests (temperature 0) decode speculatively (drafter K=5,
+exact per-row verify); other sampling decodes one token per step with vLLM's host sampler. Text only.
+Standard library only.
+"""
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from native_checkpoint import (  # noqa: E402
+    DRAFTER_MANIFEST, MANIFEST, MODEL_ID, SPEC_PROOF, _drafter_files, digest, read_manifest, require_proof,
+    verify_files,
+)
+
+RELEASE = json.loads((HERE / "runtime-release.json").read_text())
+p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+p.add_argument("--checkpoint", type=Path, default=HERE / RELEASE["checkpoint_subdir"])
+p.add_argument("--drafter", type=Path, default=HERE / RELEASE["drafter_subdir"],
+               help="it-assistant drafter dir with spec_equivalence.json")
+p.add_argument("--no-speculation", action="store_true", help="serve without the drafter (one token per step)")
+p.add_argument("--cache-root", type=Path, required=True, help="independent writable TT kernel cache directory")
+p.add_argument("--image", default=RELEASE["image"])
+p.add_argument("--port", type=int, default=8000)
+p.add_argument("--name", default="gemma4-12b-native-api")
+p.add_argument("--max-model-len", type=int, default=262144)
+p.add_argument("--device-ownership-confirmed", action="store_true")
+p.add_argument("--print-command", action="store_true")
+a = p.parse_args()
+
+checkpoint, cache = a.checkpoint.resolve(), a.cache_root.resolve()
+try:
+    manifest = read_manifest(checkpoint)
+    verify_files(checkpoint, manifest)
+    proof = require_proof(checkpoint, manifest)
+except (OSError, ValueError, KeyError) as error:
+    p.error(f"native checkpoint verification failed: {error}")
+if digest(checkpoint / MANIFEST) != RELEASE["checkpoint_manifest_sha256"]:
+    p.error("checkpoint manifest is not the one pinned by runtime-release.json")
+image_id = subprocess.run(["docker", "image", "inspect", a.image, "--format", "{{.Id}}"],
+                          capture_output=True, text=True).stdout.strip()
+if image_id != RELEASE["image_id"]:
+    p.error(f"image {a.image} is {image_id or 'missing'}, not the pinned runtime {RELEASE['image_id']}")
+if not 1024 <= a.max_model_len <= 262144 or not 1 <= a.port <= 65535:
+    p.error("invalid context length (1024-262144) or port")
+for mount in (checkpoint, cache):
+    if ":" in str(mount):
+        p.error("Docker bind-mount paths cannot contain ':'")
+if cache == checkpoint or cache.is_relative_to(checkpoint) or checkpoint.is_relative_to(cache):
+    p.error("use independent checkpoint and writable cache directories")
+
+draft_len = None
+if not a.no_speculation:
+    drafter = a.drafter.resolve()
+    if ":" in str(drafter):
+        p.error("Docker bind-mount paths cannot contain ':'")
+    dm = json.loads((drafter / DRAFTER_MANIFEST).read_text())
+    spec = json.loads((drafter / SPEC_PROOF).read_text())
+    if _drafter_files(drafter) != dm["files"]:
+        p.error("drafter file set / hash mismatch")
+    if digest(drafter / DRAFTER_MANIFEST) != RELEASE["drafter_manifest_sha256"]:
+        p.error("drafter manifest is not the one pinned by runtime-release.json")
+    if dm["target_manifest_sha256"] != digest(checkpoint / MANIFEST):
+        p.error("drafter was built for a different target checkpoint")
+    if (spec.get("drafter_manifest_sha256") != digest(drafter / DRAFTER_MANIFEST) or spec.get("streams_identical") is not True
+            or spec.get("target_proof_sha256") != digest(checkpoint / "equivalence.json")):
+        p.error("drafter lacks a speculative-equivalence proof for this target")
+    draft_len = int(spec["draft_len"])
+
+# Kernel cache keyed by what compiles into it (image + checkpoint precision + serving policy).
+cache_identity = hashlib.sha256(json.dumps({"image": image_id, "manifest": proof["manifest_sha256"],
+                                            "max_model_len": a.max_model_len}, sort_keys=True).encode()).hexdigest()[:16]
+env = {
+    "GEMMA4_SINGLE_USER": "1", "GEMMA4_NATIVE": "/model", "HF_MODEL": "/model", "HF_HUB_OFFLINE": "1",
+    "TRANSFORMERS_OFFLINE": "1", "VLLM_TARGET_DEVICE": "tt", "TORCHDYNAMO_DISABLE": "1",
+    "TT_METAL_CACHE": f"/cache/{cache_identity}",
+    **proof.get("runtime_env", {}),
+}
+command = ["docker", "run", "--rm", "--name", a.name, "--publish", f"127.0.0.1:{a.port}:8000",
+           "--device", "/dev/tenstorrent:/dev/tenstorrent",
+           "-v", "/dev/hugepages:/dev/hugepages", "-v", "/dev/hugepages-1G:/dev/hugepages-1G",
+           "-v", f"{checkpoint}:/model:ro", "-v", f"{cache}:/cache",
+           "--workdir", "/home/container_app_user/tt-metal",
+           "--entrypoint", "/home/container_app_user/tt-metal/python_env/bin/python"]
+if draft_len is not None:
+    command += ["-v", f"{drafter}:/drafter:ro"]
+for key, value in sorted(env.items()):
+    command += ["-e", f"{key}={value}"]
+command += [a.image, "-m", "vllm.entrypoints.openai.api_server", "--model", "/model",
+            "--served-model-name", MODEL_ID, "--host", "0.0.0.0", "--port", "8000",
+            "--max-model-len", str(a.max_model_len), "--max-num-seqs", "1", "--block-size", "64",
+            "--max-num-batched-tokens", "16384", "--enable-chunked-prefill", "--no-enable-prefix-caching",
+            "--seed", "0", "--enable-auto-tool-choice", "--tool-call-parser", "gemma4",
+            "--reasoning-parser", "gemma4",
+            "--additional-config", json.dumps({"tt": {"trace_mode": "all", "enable_model_warmup": True,
+                                                      "trace_region_size": 200000000}})]
+if draft_len is not None:
+    command += ["--speculative-config", json.dumps({"method": "gemma4_assistant", "model": "/drafter",
+                                                    "num_speculative_tokens": draft_len})]
+print(shlex.join(command), flush=True)
+if not a.print_command:
+    if not a.device_ownership_confirmed:
+        p.error("stop other P150 workloads and pass --device-ownership-confirmed; this launcher never stops them")
+    cache.mkdir(parents=True, exist_ok=True)
+    # Never open the P150 while another process holds it (procfs lists its users; the file size is 0).
+    pids = Path("/proc/driver/tenstorrent/0/pids")
+    while pids.exists() and pids.read_text().strip():
+        print("waiting for the P150 to be released", flush=True)
+        time.sleep(20)
+    os.execvp(command[0], command)