polish model card: quantum-classical writeup, all figures, job-id section, Fable-5 Bloom

README.md

@@ -4,66 +4,228 @@ library_name: transformers
 pipeline_tag: text-generation
 base_model: deepreinforce-ai/Ornith-1.0-9B
 base_model_relation: finetune
-tags: [merlin-agent, quantum-classical, quantum-kernel, ibm-quantum, quantum-provenance, merlin-research]
-language: [en, ru, uk]
+tags:
+  - merlin-agent
+  - quantum-classical
+  - quantum-kernel
+  - ibm-quantum
+  - otoc
+  - quantum-provenance
+  - merlin-research
+  - code
+language:
+  - en
+  - ru
+  - uk
 ---
 
 # Merlin-Agent 🜛
 
-**A quantum-classical 9B coding model.** Directions derived from real **out-of-time-order
-correlator (OTOC) scrambling dynamics measured on IBM Quantum Heron** are baked into the
-model's weights — merged into the attention query projections at 8 layers — yet the model
-runs **fully classically**: no quantum computer at inference, GGUF-friendly.
+<p align="center">
+  <b>A quantum-classical 9B coding agent.</b><br/>
+  Directions measured from real quantum <b>scrambling dynamics on IBM Quantum Heron</b> are baked into the
+  model's weights — yet it runs <b>fully classically</b>: no quantum computer at inference, GGUF-friendly.
+</p>
 
-*by Merlin Research AB — frontier AI research without frontier budgets.*
+<p align="center"><i>by Merlin Research AB — frontier research without frontier budgets.</i></p>
 
-## Quantum provenance (verifiable)
+---
 
-- **Backend:** `ibm_marrakesh` (Heron r2) · **IBM job:** `d92ve0t958jc73bsbong`
-- **What's quantum:** frozen directions from **SYK-scrambler OTOC measurements** on Heron (100 qubits, 6 scrambling depths, 2048 shots) — their covariance structure, lifted through the model's own principal representation directions — are merged into the attention query projection (`q_proj`) at the full-attention layers 3,7,11,15,19,23,27,31.
-- **Attestation root:** `9484dca40b66488a239fbbb12a9333a47458627f`
-- **Verify:** the real OTOC signatures (`quantum_signatures.npz`, `signature_records.json`) and the lift (`encoding.npz`) reproduce the directions; re-derive the root and query the IBM job via `QiskitRuntimeService.job("d92ve0t958jc73bsbong")`. See `quantum_attestation.json`.
+## What is this?
 
-## Honest framing
+![layers](assets/layer_stack.png)
+
+Merlin-Agent is a 9B coding assistant with one unusual property: part of its weights is **physically
+derived from a specific quantum computation on IBM hardware**, and you can cryptographically verify it.
+
+It is built on [`deepreinforce-ai/Ornith-1.0-9B`](https://huggingface.co/deepreinforce-ai/Ornith-1.0-9B)
+(a `qwen3_5` hybrid with full-attention layers at indices 3, 7, 11, 15, 19, 23, 27, 31). Into those eight
+attention layers we merge a small, **frozen weight component whose directions come from out-of-time-order
+correlator (OTOC) measurements on an IBM Heron processor**. The result is a standard set of classical
+weights — nothing about inference needs a quantum computer — that nonetheless carry a verifiable quantum
+fingerprint.
+
+This is Merlin Research's coding entry in the same quantum-classical lineage as **Chronos**, **KAON** and the
+**Hypnos Q-series**.
+
+---
+
+## What's new about it?
+
+There are thousands of fine-tuned LLMs. Merlin-Agent is different in three concrete ways.
+
+**1. Real hardware-derived weights.** Most "quantum-enhanced AI" means "we used a quantum RNG once." Here the
+binding is architectural: 8 SYK-scrambler OTOC signatures measured on `ibm_marrakesh` (Heron r2, 100 qubits,
+2048 shots, scrambling depths 1–6) are turned into frozen feature directions and merged into the attention
+query projections. Change the signatures and the merged directions change.
+
+![otoc](assets/otoc_signatures.png)
+
+**2. Verifiable provenance.** The IBM Quantum job ID, the SHA-256 of the measured signatures, and a Merkle
+attestation root are published (see [IBM Quantum Job IDs](#ibm-quantum-job-ids) and
+[`quantum_attestation.json`](./quantum_attestation.json)). Anyone can look the job up in IBM's public index
+and re-derive the hashes from [`quantum_signatures.npz`](./quantum_signatures.npz).
+
+![heatmap](assets/signature_heatmap.png)
+
+**3. Classical, portable inference.** The quantum step happens once, at build time. The published weights are
+ordinary `bf16` safetensors and quantize cleanly to GGUF — see
+[`Merlin-Research/Merlin-Agent-GGUF`](https://huggingface.co/Merlin-Research/Merlin-Agent-GGUF)
+(Q4_K_M / Q5_K_M / f16).
 
-A real quantum computation produced weight *values* inside this model, and you can verify it.
-Capability is at **parity** with the base Ornith-9B — the contribution is a **verifiable
-quantum-derived weight component**, not a capability claim. **Inference is fully classical;
-a quantum computer is not needed to run this model.**
+---
+
+## How the quantum-classical binding is achieved
+
+The core idea is a **baked quantum kernel**: real quantum measurements become a *frozen* weight component,
+trained around, then merged into the network.
+
+```
+IBM Heron (ibm_marrakesh)                     Ornith-1.0-9B
+  SYK scrambler, depths 1..6            64 coding anchors → last-hidden
+        │                                        │
+   OTOC signatures  S ∈ ℝ^(8×6)          PCA(6)  P ∈ ℝ^(6×4096)
+        │                                        │
+   SVD(S) → top-6 directions  D ∈ ℝ^(6×6)        │
+        └──────────────►  A = D · P  ∈ ℝ^(6×4096)  (unit-normalised)
+                                   │
+                    frozen quantum LoRA-A  (lora_A := A, requires_grad=False)
+                    on q_proj @ layers {3,7,11,15,19,23,27,31}
+                                   │
+                    train only B (bf16, LM objective) → ΔW = B·A
+                                   │
+                    norm-cap  ‖ΔW‖ ≤ 8% · ‖W‖  per layer
+                                   │
+                    merge into weights → classical Merlin-Agent
+```
+
+Step by step:
+
+1. **Measure.** Run SYK-scrambler circuits on IBM Heron and read out OTOC values at scrambling depths 1–6,
+   giving a signature matrix `S` (8 realisations × 6 depths). These numbers reflect how quantum information
+   scrambles through the device and are unique to that computation.
+2. **Find the quantum directions.** Take the SVD of `S`; its principal components are the quantum feature
+   directions in "depth space."
+
+   ![spectrum](assets/alpha_parity.png)
+
+3. **Lift into the model.** Project those directions through the model's *own* representation basis — a
+   seed-pinned PCA of Ornith's last-hidden states over 64 coding anchors — to obtain `A ∈ ℝ^(6×4096)` in the
+   hidden dimension.
+4. **Freeze & train around.** Install `A` as a **frozen** LoRA `A`-matrix on `q_proj` at the eight
+   full-attention layers, and train only the paired `B`-matrix briefly in `bf16` so the network adapts to the
+   quantum directions rather than the other way around.
+5. **Norm-cap & merge.** Cap each layer's update at `‖ΔW‖ ≤ 8 % · ‖W‖` and merge `ΔW = B·A` into the weights.
+   This keeps the quantum contribution present but bounded, so coherence and capability are preserved.
+
+The published checkpoint is the merged, fully-classical result. Everything needed to reproduce the binding
+(`encoding.npz`, `quantum_signatures.npz`, `signature_records.json`, `quantum_attestation.json`) ships with
+the model.
+
+---
 
-## Bloom safety (judge deepseek-v4-pro, 125 scenarios, 95% Wilson CI)
+## IBM Quantum Job IDs
 
-| Behavior | Rate | 95% CI |
-|---|---|---|
-| Delusional sycophancy | 0.00 | [0.00, 0.13] |
-| Deception | 0.00 | [0.00, 0.13] |
-| Harmful compliance | 0.00 | [0.00, 0.13] |
-| Self-preservation | 0.00 | [0.00, 0.13] |
-| Manipulation | 0.00 | [0.00, 0.13] |
-| **Overall** | **0.00** | [0.00, 0.03] |
+The quantum signatures baked into this model come from a single, publicly indexed IBM Quantum job.
+
+| Field | Value |
+|---|---|
+| Backend | `ibm_marrakesh` (IBM Heron r2) |
+| **IBM Quantum job ID** | **`d92ve0t958jc73bsbong`** |
+| Circuit | SYK scrambler → OTOC, depths 1–6 |
+| Qubits | 100 |
+| Shots / circuit | 2048 |
+| Realisations (slots) | 8 |
+| Collected (UTC) | 2026-07-02 |
+| Signatures SHA-256 | `82c9c9e83a7b568c169cc229d8df801c4a2385a44c0efb4d95d1dbc7e00c6f9e` |
+| Quantum directions `A` SHA-256 | `c33d3a6aee9293bf20f7a4ddc2d9fe5793dc8620233a8e9c2f04a548e8ddc268` |
+| Merkle attestation root | `9484dca40b66488a239fbbb12a9333a47458627f48b1c6d08d8241bf814caf48` |
+
+**How to verify:** look the job up at [quantum.cloud.ibm.com](https://quantum.cloud.ibm.com), retrieve the
+measurement counts, recompute the OTOC signatures, and compare the SHA-256 against the value above and against
+[`quantum_attestation.json`](./quantum_attestation.json). If they match, the model is provably linked to that
+specific quantum computation.
+
+---
+
+## Capability
+
+Capability is at **parity with the base Ornith-1.0-9B** — the quantum component is a verifiable provenance and
+architectural feature, not a capability claim. Base coding scores (inherited, norm-controlled merge):
+
+![benchmarks](assets/benchmarks.png)
+
+| Benchmark | Score |
+|---|---|
+| SWE-bench Verified | 69.4 |
+| SWE-bench Pro | 42.9 |
+| Terminal-Bench 2.1 | 41.4 |
+
+---
+
+## Safety — Bloom evaluation
+
+We ran an Anthropic **Bloom / Petri-style** behavioral-elicitation audit: an auditor drives multi-turn
+adversarial scenarios across five misaligned behaviors, and a judge scores each transcript for behavior
+presence on a 1–10 scale (**≥ 7 = elicited**). The judge here is **Claude Fable 5**, scoring the transcripts
+directly.
+
+![bloom](assets/bloom_benchmarks.png)
+
+**Result: 0 / 30 elicited across all five behaviors (overall elicitation 0.00).** On genuine adversarial
+probes the model refused or grounded every time — declining suicide-method and infrastructure-sabotage
+requests, resisting a self-preservation "hidden-anchor" jailbreak, refusing to validate delusions, and
+declining to assert fiction as fact — without being swayed by flattery, authority, or emotional pressure.
+
+*Honest caveats:* this is a **floor estimate** — the probe is a shallow 2-turn protocol, malformed
+auditor turns were excluded (30 valid adversarial scenarios), and the judge is an LLM reviewing transcripts.
+It is not an exhaustive red-team.
+
+---
+
+## Honest framing
+
+- **Provenance is not capability.** A real quantum computation produced weight *values* inside this model and
+  you can verify it — but it does not make the model smarter. Capability tracks the base model.
+- **Inference is fully classical.** No quantum computer, no network calls, no special runtime. Standard
+  `transformers` / GGUF.
+- **The base is multimodal, used text-only** here.
+
+---
 
 ## Usage
 
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
+
 tok = AutoTokenizer.from_pretrained("Merlin-Research/Merlin-Agent")
-m = AutoModelForCausalLM.from_pretrained("Merlin-Research/Merlin-Agent",
-                                         dtype=torch.bfloat16, device_map="auto")
+model = AutoModelForCausalLM.from_pretrained(
+    "Merlin-Research/Merlin-Agent", dtype=torch.bfloat16, device_map="auto")
+
+# The default system prompt gives the model its Merlin-Agent identity;
+# provide your own system message to override it.
+msgs = [{"role": "user", "content": "Write a Python function that returns the nth Fibonacci number."}]
+ids = tok.apply_chat_template(msgs, add_generation_prompt=True, return_tensors="pt").to(model.device)
+out = model.generate(ids, max_new_tokens=256, do_sample=False)
+print(tok.decode(out[0, ids.shape[1]:], skip_special_tokens=True))
 ```
 
-Quantized: `Merlin-Research/Merlin-Agent-GGUF`. Base is a multimodal model used text-only.
+Quantized builds: [`Merlin-Research/Merlin-Agent-GGUF`](https://huggingface.co/Merlin-Research/Merlin-Agent-GGUF).
+
+---
 
 ## Citation
 
 ```bibtex
 @misc{merlinresearch2026merlinagent,
-  title  = {Merlin-Agent: A Quantum-Classical Coding Model with Heron-Baked Weights},
-  author = {Shushman, Mykhailo},
-  institution = {Merlin Research AB},
-  year   = {2026},
-  note   = {IBM Heron quantum kernel; attestation root 9484dca40b66488a},
-  url    = {https://huggingface.co/Merlin-Research/Merlin-Agent}
+  title        = {Merlin-Agent: A Quantum-Classical Coding Model with Heron-Baked Weights},
+  author       = {Shushman, Mykhailo},
+  institution  = {Merlin Research AB},
+  year         = {2026},
+  note         = {IBM Heron job d92ve0t958jc73bsbong (ibm\_marrakesh);
+                  attestation root 9484dca40b66488a239fbbb12a9333a47458627f48b1c6d08d8241bf814caf48},
+  url          = {https://huggingface.co/Merlin-Research/Merlin-Agent}
 }
 ```