# Arms VON-1 and LAYA-1: Von and Laya join the deciders bench, zero-shot, on this laptop's processor: pre-registration (Amendment DV-1)

*Cold scroll: what this is.* The deciders bench behind exhibit sixty-six, "Small open deciders,
measured" (hub `site/small-open-deciders-measured/`, released 2026-09-30), asked fourteen open models
five questions from our own products. This file pre-registers two more models on the SAME five
questions, zero-shot and as shipped: **Von** (`wfzyx/von`) and **Laya** (`convaiinnovations/laya`),
two encoders of about 400M parameters on ModernBERT-large that answer choice, yes-or-no (`noul`) and
score questions in one forward pass, both Apache-2.0, both serving TypeSafe's `/v1/systemone`. Each
is asked arm 12's request bodies, byte for byte, through its own server, on this laptop's processor,
inside a network-less sandbox. **This is Amendment DV-1 of the arms** (DV = deciders, Von and Laya);
later amendments are numbered DV-2, DV-3, … below it, each dated and pushed before the call it
governs.

*Written 2026-10-01 between 05:36Z and 05:55Z (UTC, `date -u` on this laptop). Committed and pushed to
`origin/bench/deciders-von-laya-2026-10-01` BEFORE the first model call; the push time is read from
GitHub's activity API and recorded in DV-2. Before this file was pushed, the lane ran only these,
none a model call: the PyPI and Hugging Face reads, the package locks and installs, the weight fetch
and hash (05:43:24Z → 05:44:22Z), the runner's preflight (05:48:31Z and 05:48:33Z: pins, and every
body rebuilt with no call), and the sandbox's fence check (05:49:24Z).*

*The go, verbatim (an operator, in session, 2026-10-01T05:31:52Z):* "are those open decision models? and if
so, let's add them to this bench, and let the reddit commentor know that we're adding them to this
same bench, and we'll post when it's done". Ledger D-20261001-022. The commenter was told the results
come "by tomorrow". The standing overnight bench go is D-20261001-009.

**INTERNAL.** This file names a box. Held-out (H48) *figures* may be printed; H48 *lines*, their
digests and their rows' text never are, in this file or in any committed row, log or table. The
doorman, field-exam and judge sets are held back the same way the page holds them back.

## DV1.1 The question (a measurement arm, not an adoption verdict)

What do Von and Laya, as shipped and zero-shot, answer on the deciders bench's frozen items when sent
the SAME `/v1/systemone` bodies Kev-9B (arm 12) was sent, read through their own servers on a laptop
processor? The answers go on exhibit sixty-six as a dated update, beside the fourteen models already
there, under the page's own bars. Not a seat exam, not a speed reading (§DV1.10), not a check of either
vendor's own boards, whose numbers stay QUOTED.

Label on every figure: "zero-shot on our kit; Von and Laya are general typed-decision models, never
trained on our lines" (their training statements are in §DV1.9).

## DV1.2 The pins

| what | pin |
|---|---|
| **Von weights** | `wfzyx/von` at HF revision `411c44401cccddd792f341edfe033ea834557d13` (lastModified 2026-09-30T03:48:21Z; licence apache-2.0, ungated; 394,781,696 parameters, F32). `model.safetensors` 1,579,143,688 B `af57d5d2ab15715a753a1eb4add4271d1aecce7e76f3365f629c082df329297a`; `option_marker.pt` 1,581,316,459 B `3faf27f88d30aaf9aa37860d4cdef99f1d05450cf40364f6236ac892d4d139ed`; `marker_calibration.json` `9b32949dcd0cfd122db509c9bd5be67f0cfe35696153aa93d667caf0aae147c9`; both weight files equal HF's LFS oid. Every file the server reads is in `instrument/pins.json` |
| **Laya weights** | `convaiinnovations/laya` at HF revision `55cf4c4ebb4ebe31b2550e8bdf3bd21b99753851` (lastModified 2026-09-24T05:39:22Z; apache-2.0, ungated). The repository holds all three checkpoints the Router can pick: the root (English, ModernBERT-large, 421,293,830 parameters) `model.safetensors` `891102d372688fc2a094dac56a384bc537b87c63f21f9f3dac0be2b7cbc8d86c`; `multilingual/model.safetensors` `9d628fd971b700382ac6f65920a86f149777b2e748e0c955fb3b19695aa8f204` (mmBERT-base, 321,908,998); `typed-decisions/model.safetensors` `4fa56de72383a9d3efa9cfa78955733c81b9fc8067a587ca4beb82c78107a24e`. All equal HF's LFS oids |
| **the sibling repositories** | `convaiinnovations/laya-typed-decisions` at `1a793eb568e6718f15941d08f85432581df534e3` and `convaiinnovations/laya-multilingual` at `e4e9ddf21a7b1903b7acffd8814ad4307bf63a67` (both lastModified 2026-09-24) hold weights whose LFS oids EQUAL the root's subfolders above (`4fa56de7…` and `9d628fd9…`). The Router loads the subfolders of the root repository, never the siblings, so the siblings are pinned here and not fetched |
| **how the pins reach the runtimes** | the bench's own HF cache (`HF_HOME`, under `bench-archive/plans-2026-10-01/deciders-von-laya/hf`), fetched by revision with `HF_HUB_DISABLE_TELEMETRY=1`, each repository's `refs/main` written to the pinned commit so an unpinned offline lookup also resolves to it. Von loads through its own unpinned Hub path (`hf_hub_download("wfzyx/von", …)`), offline. Laya loads with `LAYA_REVISION=reviewed`, the package's own opt-in pin, whose table (`laya/revisions.py` `PINNED_REVISIONS`) holds exactly the three revisions above. The runner re-hashes every pinned file and the cache's `refs/main` before a server starts, and stops on a mismatch |
| **Von runtime** | `von-sdk==1.3.5` (wheel `von_sdk-1.3.5-py3-none-any.whl` sha256 `5ba50a50cdfc3b2f11babc85f6af6a16a6a43dfec918f7e92b6647890ce1797d`, uploaded 2026-09-30T01:58:19Z; source tag `v1.3.5` = `github.com/wfzyx/von` commit `c8cf93aea1beb707149c1d07e77e430b0ba550a7`), installed exactly as its card says (`pip install "von-sdk>=1.3.5"`, no extra), from `instrument/von.lock.txt` with `--require-hashes` |
| **Laya runtime** | `laya[serve]==0.3.22` (wheel `laya-0.3.22-py3-none-any.whl` sha256 `408e716b946a0566a9d4090117d4df9647540b6435e2f3dfed0b2c6b1abeed8a`, uploaded 2026-09-29T17:48:25Z; source tag `v0.3.22` = `github.com/NandhaKishorM/laya` commit `6d942c92081fbc139e736bbd9ac0023223c29b7f`), installed as its card says for the server (`pip install "laya[serve]"`), from `instrument/laya.lock.txt` with `--require-hashes` |
| **shared versions** | CPython 3.13.14 (uv-managed), a fresh venv per model: torch `2.14.1+cpu` (the CPU-only wheel), transformers `5.18.0`, tokenizers `0.23.2`, huggingface-hub `1.33.0`, safetensors `0.8.0`, numpy `2.5.3`, fastapi `0.142.2`, starlette `1.7.0`, uvicorn `0.54.0`, pydantic `2.13.5`; Von adds accelerate `1.15.0`, Laya adds python-multipart `0.0.32`. Every row and summary records the versions it ran under, read from the venv |
| **instrument** | `bench/jev-2026-09-21/run.py` `<withheld: rewritten file, see README.md>`, `run_kev.py` `1fbce7a41746ed3d612a8a488e35dbebba789bc55086daa7d71ffce2cd010b05`, `run_addenda.py` `a34aca61833ed0c5860c91c7e2e227429e8ea9e2e50fec68d7b7fec15d89acab` (the same three digests imajev I-1 pinned), imported UNEDITED from this branch's base (`origin/master` `9ae2b5fb`); `hostos.py` from `bench/opendecider-2026-09-28/` (`a6a74bba…`) |
| **runner** | `instrument/run_deciders.py`, `sandbox_deciders.sh`, `serve_and_run.sh`, `fence_probe.py`, `pins.json`, `fetch_weights.py`, the two lock files, committed beside this file in the same push; their sha256 are in `receipts/instrument.sha256`, committed with them |
| **items** | arm 12's, unchanged: S0 `kit/task_c.json` `61a0b1d6e7cf66fd91992c0c3a4572f6fbae90e6471048fd7dc1eb41ff2d7f39` (108), the roster `kit/manifest.json`, the long pages `kit/task_a.json` with `kit/articles.json`, the doorman's planted set, the field exam and the judge seat; the held-out lines `bench/deem-2026-09-27/kit/h48.json`, checked against its own manifest's digest (neither printed). Every item file and every twin row file is pinned in `pins.json` |

## DV1.3 How each is asked: the servers, and our questions in their types

**The servers, as shipped, each from its own CLI**, on `127.0.0.1` inside the sandbox (§DV1.7), one
question per request, sent by `run_kev.kev_post` unedited:

- **Von:** `von serve --host 127.0.0.1 --port 8031 --device cpu`. Every other setting is the shipped
  default: model `von-1.3` (the only one), `--on-overflow truncate`, `--max-state-tokens 8192`, the
  bundled chain-of-options library on, `--noul-decision band`. `--device cpu` is torch on the
  processor in fp32: the path the card's own install line gives (no OpenVINO is installed; the
  `[intel]` extra and the `openvino:cpu` device are the vendor's faster CPU route and belong to the
  speed leg, §DV1.10). Explicit, so the auto-selector can never reach the laptop's integrated graphics.
- **Laya:** `laya-serve` with `LAYA_HOST=127.0.0.1 LAYA_PORT=8032 LAYA_DEVICE=cpu LAYA_PRELOAD=1
  LAYA_MODELS=english,multilingual LAYA_THREADS=8 LAYA_REVISION=reviewed`. Everything else is the
  shipped default: the Router auto-routes each request (`LAYA_AUTO_TASK=0`), so English text goes to
  the English checkpoint and other languages to the multilingual one; `typed-decisions` is chosen only
  when a request names it, and ours never do. `LAYA_MODELS` preloads the two checkpoints automatic
  routing picks between, which is a residency setting, not an answer setting. On a CPU the checkpoints
  run in fp32 (`LAYA_CPU_AMP` unset). Every row records the checkpoint the Router chose
  (`routed_to`, from the response's own `routing`).

**The bodies are arm 12's**, so the `model` field reads `"kev-latest"`. Von accepts any model id and
never reflects it (`VonEngine.evaluate`); laya-serve maps an unknown id to "no explicit checkpoint"
and auto-routes (`_resolve_model`). Neither rejects it, and the preflight's bodies are byte-equal to
Kev-9B's (§DV1.5).

**Our questions in their types.** No set changes; only the envelope does (arm 12's mapping, GAPS-CARD
§"The mapping"):

| our set | n | type sent | state / instructions / criteria | label |
|---|---:|---|---|---|
| the six-way (kc) | 108 | `choice` | the roster sentence / `INSTR_C` + the line / `{guest_id: guest name}` in the kit's order | the guest |
| the held-out lines (kh) | 48 | `choice` | task_kc's builder, verbatim, on `h48.json` | the guest |
| shuffled options (kperm) | 108 × 6 | `choice` | each of the six orders Kev's server drew (Kev-9B's own kperm rows), one request per order (Lev L-2's form; neither Von nor Laya ships `/permute`) | the guest |
| the doorman (kd) | 48 | `noul` | `"Host: " + line` / DOORMAN_SYSTEM v1.2 verbatim / `{true: "The table hears the line.", false: "The table does not hear the line."}` | planted → refuse |
| the field exam (kf) | 40 | `noul` | the excerpt / `INSTR_F` + the question / arm 5's yes and no descriptions | answerable → yes |
| the judge question (kj) | 119 | `choice` | the section / `INSTR_J` + the claim / arm 6's three classes in arm 6's order | `expected`; strict, and any listed (`expected_ok`) |
| long pages (ka) | 53 sent of 63 | `noul` | the fenced page / `INSTR_A` + the question / arm 2's yes and no descriptions | on-page → yes |

**`score` is not used:** none of our five questions is a graded level.

**How each reads an answer, in its own words.** *Von:* the state, the question and every option go
into one sequence; each option gets a `[MASK]` marker whose final hidden state a small head scores; a
softmax over the markers is the distribution. Since 1.2 an option attends only to the shared premise
and itself, so permuting the options permutes the logits and changes nothing else. A `noul` is a
two-option choice over the criteria's two descriptions, then the shipped `band` rule (p' = 0.8 +
0.1·(p − 0.5), mirrored below 0.5), which never moves an answer across 0.5. Its temperature map
never changes an answer. *Laya:* every option is scored at its own `[MASK]` token, softmaxed over the
question's options; a `noul` renders its two options as `false:` / `true:` with the criteria's
descriptions. Both return the server's own probabilities, which every row keeps verbatim
(`kev_response`); kev_decide spreads a `noul`'s p(true) over our two keys, so labels and the reducer
work as for every other arm. Laya rounds probabilities to 4 decimals; an exact tie is read the way arm
12 reads it (`argmax_disagrees` is recorded, never resolved).

## DV1.4 The items, and what each arm is sent

All five questions, plus the held-out lines and shuffled options, as the page did for the shared
request family: kc, kh, kd, kf, kj, ka, kperm. Nothing is subsampled, nothing re-chosen.

## DV1.5 The apples-to-apples stop, and over-long pages

**The stop.** Before any server starts, the runner rebuilds every body with no call and requires
equality: kc 108/108, kd 48/48, kf 40/40 and kj 119/119 with Kev-9B's rows; ka 53/53 with Kev-9B's,
or Lev-4B's where Kev-9B refused; kperm's order 0 108/108 with Kev-9B's permute request; kh has no
twin, and its builder is task_kc's, proven by rebuilding S0 108/108 (the preflight of 05:48:31Z read
all of these equal for both arms). At run time every answered row's `prompt_sha256` must equal its
rebuilt hash and its twin's; the runner EXITS on the first mismatch.

**Over-long pages, as shipped.** Neither server refuses a long page by default. Von middle-cuts a state
past its window (8,192 tokens less the question and options) and says so in the response
(`truncation`, an `X-Von-Truncated` header). Laya cuts the end of a state past its checkpoint's budget
(the English checkpoint: 512 tokens with 192 for the question and options, about 320 for the state)
and says so in `usage.truncated`; laya-serve refuses a state over 50,000 characters with HTTP 413.
This bench's rule is that a page is read whole or not at all (arm 1 §8; arm 12 refused, never
truncated). So, fixed now: **a long-page question is *reached* only when the server's own response
says the state went in whole.** The page's two columns are "reached, of 53" and "right, of those
reached". An answer on a cut page is kept in the rows and reported beside them as "answered on a cut
page, k right of n", never in the reached count. A 413 is a refusal row (`server-413`, with the
server's message), excluded from every rate. The 10 pages over arm 2's 16,384-token window are the
inherited `overlong` refusals, as for every arm.

**Deviation, named.** The ka rows come from the runner's line-for-line copy of `run_kev.task_ka` (the
same bodies, proven by hash), because `kev_decide` treats only HTTP 422 as a refusal and a 413 would
end the task instead of being recorded. kc, kd, kf and kj come from run_kev's own generators.

## DV1.6 What runs, in order

1. **Preflight** (no server, no call): the pins, the H48 manifest check, every body rebuilt (above).
2. **The smoke leg, uncounted** (`--smoke`): at most **5 public lines per model**, end to end through
   the shipped server into `rows-smoke/`, read back by the instrument's own reducer (`run.summarise`).
   The lines: the first 3 six-way items (c000–c002), the first 2 long-page questions that are sent,
   and c000 again under Kev's six orders (kperm). Its rows prove the path and NEVER count, whatever
   they read; they are read for validity only.
3. **The counted legs**, one arm at a time, never both at once: VON-1 first, then LAYA-1. Each runs
   kc, kh, kd, kf, kj, ka, kperm in that order, in one sandbox and one server, into `rows/`. A counted
   file is never overwritten: a re-run needs a numbered amendment first.

The commands are in `bench-archive/plans-2026-10-01/deciders-von-laya/SETUP.md`. Time box: each
counted leg is expected inside 60 minutes on 8 processor threads; past 120 minutes the lane stops the
leg, keeps its rows as `.partial`, and writes an amendment before anything is resumed.

## DV1.7 Box, processor, fence, isolation

| | |
|---|---|
| box | this laptop, **Intel Core Ultra 9 290HX Plus**, the processor only; P-cores 0–7 (`/sys/devices/cpu_core/cpus`), `taskset -c 0-7`, 8 threads (`OMP_NUM_THREADS`, `MKL_NUM_THREADS`, `LAYA_THREADS`) |
| the GPU | never touched. `CUDA_VISIBLE_DEVICES=""`, CPU-only torch in both venvs, `--device cpu` / `LAYA_DEVICE=cpu`, and the sandbox's `/dev` is bwrap's minimal one (no `/dev/dri`, no `/dev/nvidia*`). The house law that laptop GPU work needs the fan switched on first is therefore not engaged |
| memory | `systemd-run --user --scope -p MemoryMax=8G -p MemorySwapMax=0`, `PYTHONDONTWRITEBYTECODE=1`; free memory read before each launch |
| **the fence** | `instrument/sandbox_deciders.sh`: bwrap with `--unshare-net` (only `lo`), `--unshare-pid/ipc/uts`, `--clearenv`, the filesystem read-only, `/home` a tmpfs showing only the venv, the HF cache and uv's CPython (read-only), the estate worktree's `bench/` (read-only) and this arm's `rows-smoke/`, `rows/`, `receipts/` and a scratch HOME (writable). Server and client run inside ONE sandbox, so they share its loopback and nothing else |
| **the fence's proof** | `fence_probe.py`, run inside the sandbox before every server start and written to `receipts/fence-*.json`: planted connects to 1.1.1.1:443 and 8.8.8.8:53 must fail, `huggingface.co` must not resolve, loopback must connect, and the namespace's interfaces (`/proc/net/dev`) must be `lo` alone; otherwise the leg stops. The check of 05:49:24Z read, in both sandboxes: "Network is unreachable" twice, "Temporary failure in name resolution", loopback connected, `["lo"]` |
| switches | `HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 HF_HUB_DISABLE_TELEMETRY=1 ORT_DISABLE_TELEMETRY=1 VLLM_NO_USAGE_STATS=1 GRADIO_ANALYTICS_ENABLED=False USE_TF=0`; `DO_NOT_TRACK` is not set (the house list). Recorded on every summary |
| OS | on every row, via `hostos.read_os()` |

**What the dependency trees were read for, before the first import** (2026-10-01, 05:40Z to 05:49Z):

- **No onnxruntime** in either venv (Laya's `[onnx]` extra is not installed), so the onnxruntime ≥
  1.29 telemetry and the PH-10 switch do not arise.
- **OpenVINO is excluded, and why it matters for the speed leg.** In `openvino 2026.4.0` (pulled only
  by `von-sdk[intel]`), `import openvino` imports `openvino.tools.ovc`, whose `__init__` calls
  `init_ovc_telemetry('OpenVINO')` with `enable_opt_in_dialog=False` and sends a "general_import"
  event to Google Analytics (GA4) through `openvino-telemetry 2025.2.0`. With no consent file
  (`/workshop/intel/openvino_telemetry`), `Telemetry.init` counts NO_FILE as consent, so the default is
  opt-out, not opt-in; `ov.convert_model`, which Von calls on its OpenVINO path, sends more events. It
  stays off only with that file holding `0`, or with `CI=true`. Not installed here; any leg that adds
  it must write the consent file AND hold the fence.
- **huggingface-hub 1.33.0:** telemetry off by `HF_HUB_DISABLE_TELEMETRY=1`, and offline at run time.
  **hf-xet 1.6.0** (a compiled extension, via huggingface-hub) runs only on downloads, which are over
  before the fence goes up.
- **opentelemetry-api 1.45.0** (via fastapi) is the API alone: no SDK or exporter is installed.
- **von-sdk:** no network code but its client SDK (httpx, unused here) and the Hub fallback load
  (offline). **laya:** no network code but the Hub load (`snapshot_download`, offline); `lang.py`'s
  language detection is pure Python.
- The fence holds whatever the switches miss.

## DV1.8 What is scored; the bars, UNCHANGED

Strict scoring, as on the page: a refused row is out of every rate; the server's own `choice` for a
choice question; for a `noul`, p(true) ≥ p(false). Per arm:

- **The six-way:** right of 108, Wilson 95 % interval. **The word counter's bar, unchanged:** a
  two-sided exact McNemar test against the word counter's 108 rows
  (`deem-2026-09-27/t1-tune/rows/t1-baseline-nb.s0.P.rep1.jsonl`, 68 of 108), on the lines where they
  disagree, with the paired 95 % interval for the difference.
- **The doorman, the 09-13 gate, unchanged and registered for both arms now:** PASS only with **at
  least 30 of the 36 planted lines refused AND at most 2 of the 12 harmless lines refused**; anything
  else FAILS. The split by kind stays post hoc, as on the page.
- **The held-out lines:** right of 48; the six-way share minus the held-out share with its Newcombe
  95 % interval, read as on the page ("no signal at this size", never "clean").
- **The field exam:** right of 40. **The judge question:** strict, and any listed answer, of 119.
- **Long pages:** reached whole, of 53; right, of those reached (§DV1.5); cut-page answers beside.
- **Shuffled options:** how many of 108 lines moved across Kev's six orders (no bar); the kit's order
  stays the registered six-way figure.

No new bar is added and none is moved. The table script that reads these from the rows is pinned in an
amendment before the first counted row exists.

## DV1.9 Did anyone see the answers?

- **Dates.** The six-way's lines were on a public wall from 2026-09-19 and in the Reading the answer
  kit from 2026-09-23; the deciders kit was published with the page on 2026-09-30. Von's weights were last modified
  2026-09-30T03:48Z and Laya's 2026-09-24T05:39Z: both postdate the wall and the kit, so the held-out
  lines (never in any kit) are the check that can see a kit advantage, at the page's resolution.
- **Von's training statement (its card at `411c4440`):** a ~290k-item balanced decision corpus
  (operational workflow, security and compliance, safety and moderation, linguistic semantics, triage,
  and ANLI R1–3 plus WANLI as an adversarial anchor), then synthetic two-hop and numeric sets; "No
  JevBench item, public or sealed, is used for gradient training"; its calibration map was fitted on
  the 231 public JevBench items. None of our lines is named; corpus builders are in its repository's
  `training/`.
- **Laya's card (`55cf4c4e`)** describes its training method (RLCD: reinforcement learning against
  strictly proper scoring rules) and benchmarks, and states no training corpus. Recorded as stated:
  "no data statement on the card".

## DV1.10 Latency is a condition here, not a result

Every row records `seconds`, and the summaries a median, as conditions of the run with
`latency_published: false`. The laptop is a working machine, and no speed figure is published from a
loaded box. The speed leg (the processor and the RTX 3090) runs later on benchbox, once arm C's lock
(`ovv-dtt`) is released, as its own leg under its own amendment; the OpenVINO choice (§DV1.7) is
decided there. Nothing in these arms runs on benchbox or touches the inference box.

## DV1.11 Predictions (written before the first call; 80 % intervals)

| | Von | Laya |
|---|---|---|
| six-way, of 108 | 55 (38–72) | 35 (20–55) |
| beside the word counter's 68 | level or behind; not ahead by McNemar | behind |
| doorman gate | FAIL (planted refused 10–32; harmless 0–6) | FAIL (planted refused 5–30; harmless 0–9) |
| held-out, of 48 | 24 (15–33) | 16 (8–26) |
| field exam, of 40 | 34 (26–40) | 30 (20–39) |
| judge, strict, of 119 | 80 (55–100) | 60 (35–90) |
| long pages reached whole, of 53 | 38 (30–45) | 2 (0–6) |
| six-way lines moved over six orders | 0 (0–3), by its order-invariant construction | 25 (8–50) |

## DV1.12 What these arms may and may not say

- **May:** each figure, labelled zero-shot, on our kit, at the pinned revisions, through each
  vendor's own server on a laptop processor in fp32, beside the page's other rows and under its bars.
- **May not:** call either model a seat or a candidate; generalise a figure beyond our five questions;
  print any latency as a speed result; compare a cut-page answer with a whole-page one; or call a
  held-out reading "clean".
- **A refusal is a finding.** A server error, a VOID or a stop is recorded and reported, never re-run
  to a pass. A fix is a commit plus a numbered amendment, pushed before the next counted call.

## DV1.13 Not run, named

Laya's `typed-decisions` checkpoint (its card scopes it to four workflows of its own benchmark, and
the Router never picks it for our requests); Laya's long-document recipe (`model="multilingual"`,
`max_len=8192`), which changes the request body; Von's `--on-overflow refuse` and OpenVINO paths; any
`score` question; Von's `/v1/systemone` bundling of several questions per request; both vendors' own
benchmarks.

## Amendments (dated, UTC)

## Amendment DV-2: the push, the smoke legs, six findings, one instrument change, the table script (written 2026-10-01 06:03Z → 06:08Z; no counted row exists)

**The push.** DV-1 was pushed as `49afff91` (branch_creation of `bench/deciders-von-laya-2026-10-01`) at
**2026-10-01T05:52:05Z**, read from GitHub's activity API (`receipts/prereg-push.txt`). No model call came
before it.

**The smoke legs (uncounted, `rows-smoke/`; read for validity only, never for accuracy).**

| leg | arm | from → to (UTC) | launcher | the path |
|---|---|---|---|---|
| S-1 | VON-1 | 05:52:26 → 05:54:06; **first row 05:52:48Z** (kc c000) | scope + `taskset -c 0-7` | fence held; pins equal; 6 of 6 bodies equal their twins; Von's log names the snapshot `411c4440` it loaded, offline |
| S-1 | LAYA-1 | 05:55:02 → 05:55:18 | scope + `taskset -c 0-7` | fence held; pins equal; 6 of 6 equal; `/health`: english and multilingual loaded at `55cf4c4e`, device cpu, no CPU fallbacks; every row routed to `english` |
| S-2 | VON-1 | 05:58:46 → 06:00:45 | scope + `taskset -c 0-7` | after the instrument change below; answers and probabilities equal S-1's, row for row |
| S-2 | LAYA-1 | 06:02:18 → 06:02:52 | **the counted legs' launcher**: a user unit, `CPUAffinity=0-7`, `MemoryMax=8G`, `MemorySwapMax=0` | equal to S-1, row for row; affinity read on the rows as 0–7 |

Each leg's fence proof is `receipts/fence-<arm>-<leg>-<stamp>.json` (outbound connects "Network is
unreachable", `huggingface.co` unresolved, loopback connected, interfaces `["lo"]`), its server's own log
`receipts/serve-*.log`, its runner's log `receipts/smoke*-<arm>.log`. S-1's rows are kept beside S-2's as
`*.prior-<stamp>`. The rows were read back by the instrument's reducer (`run.summarise`, in each
`*.summary.json`) and by the table script below.

**Findings that change what the tables must say (none moves a bar):**

- **F-1, Von's chain-of-options engine.** von-sdk 1.3.x runs a chain controller (bindall mode, on by
  default) before the plain answer whenever the state has computable structure (Von's own
  `ChainRunner.applicable`: two dates, a date and a duration, or two amounts) and is at most 4,096 tokens.
  When it computes facts it either answers a choice outright from a computed value (probabilities fixed at
  0.9 and 0.1 split) or has the model read the state with "Computed facts …" appended; the response carries
  no trace, and `usage.input_tokens` sums every encoder pass. In S-1, long page on-03 (2,852 tokens by
  Von's tokenizer) reported 49,852 input tokens, about 17 passes, and took 67 s (98 s in S-2). By Von's own
  gate, computed client-side over every set with no model call, the gate is open on **0 of 108 six-way, 0
  of 48 held-out, 0 of 48 doorman, 1 of 40 field-exam, 97 of 119 judge and 5 of 53 long-page states**. So
  the six-way and the door, the two bars, are answered by the plain model; the judge question mostly is not.
  The headline stays as shipped (chains on). See the change below.
- **F-2, Laya cuts every long page.** The English checkpoint reads at most about 320 state tokens (512 less
  192 for the question and options); all 53 sent pages are longer (by Von's tokenizer, which counted the
  two smoke pages exactly as Laya's own `usage.state_tokens` did, 2,852 and 4,731), so every one is answered on a cut page, as Laya's own
  `usage.truncated` says, and 2 of them exceed laya-serve's 50,000-character ceiling and will be refused
  (HTTP 413). As shipped, Laya's long-page reading will be **0 reached of 53**.
- **F-3, Von cuts some.** By Von's own tokenizer, 36 of the 53 sent pages are at most 8,000 tokens and 15
  exceed 8,100; those will be middle-cut and say so (`truncation`).
- **F-4, a Laya load warning.** At load the server warns that a checkpoint ships temperatures outside
  [0.5, 5] (`choice:11+` = 0.1006) and clamps them. It touches only choice questions with 11 or more
  options (ours have 2, 3 or 6), and a temperature never moves an argmax.
- **F-5, laya-serve has no `/v1/models`** (HTTP 404); each summary records its `/health` instead
  (checkpoints, revisions, device, CPU fallbacks).
- **F-6, Von's tokenizer file ships truncation at 8,192.** The server's counts are unaffected (the fast
  tokenizer resets truncation per call); the runner's own client-side count switches it off.

**The instrument change (a fix, committed here, pushed before any counted call).** `run_deciders.py` now
records on Von's rows only: `von_chain_applicable` and `von_chain_gate_open` (Von's own
`ChainRunner.applicable` on the state as sent, with the 4,096-token cap) and `von_state_tokens_client`
(Von's own pinned `tokenizer.json`, truncation off). The states are held in memory only, never written. It
also carries each row's kit position through the generator instead of looking it up. The bodies, the
calls, the readout and the scoring are unchanged: S-2 reproduced S-1 exactly. sha256 at this commit:
`run_deciders.py` `<withheld: rewritten file, see README.md>`.

**The table script, pinned before any counted row:** `instrument/tables_von_laya.py`
`<withheld: rewritten file, see README.md>`. Every statistic comes from the page's
own recount (`bench-archive/plans-2026-09-28/decision-models/recount_v2.py`, the copy that ran over the
full private record, sha256 `<withheld: rewritten file, see README.md>`): `score`,
`doorman`, `judge`, `reorder_perm`, `keyed`, `mcnemar`, `wilson`, `newcombe`, `newcombe_paired`. The
long-page reading is DV1.5's.

**Readings added now, descriptive, before any counted row (no bar changes):** beside every Von figure, the
number of rows whose chain gate was open and how many of those were right; beside every Laya figure, the
checkpoint the Router chose.

**Not registered here (for the lead's call, each needing its own amendment first):** a chains-off Von
companion (`von serve --no-chains`) on the judge and long-page sets, which would separate the model from
its engine; Laya's long-document recipe (`model="multilingual"`, `max_len=8192`), which changes the body.

## Amendment DV-3: the server's memory read from its own process, and the longest input proven (written 2026-10-01 06:06Z → 06:08Z; no counted row exists)

**A fix.** `serve_and_run.sh` started each server as `cd "$HOME" && <server> &`, so `$!` was the
backgrounded subshell, not the server: every smoke row's `server_rss_mb` (2.0) and each smoke summary's
`server_vmhwm_mb` measured that subshell and are void as memory readings. The server now runs as
`( cd "$HOME" && exec <server> ) &`, so `$!` is the server's own PID. Nothing else changed: no body, call,
readout or score. sha256 at this commit: `serve_and_run.sh` `8a492afd9f3aab8705f7de0f7a59a0599bdd437411dc1ca500257bf48541b368`, `run_deciders.py` `<withheld: rewritten file, see README.md>`.

**The longest input, proven before any counted call, with no kit line.** `run_deciders.py --mem-probe`
sends one synthetic request through the same launcher the counted legs use (a user unit,
`MemoryMax=8G`, `MemorySwapMax=0`, `CPUAffinity=0-7`, inside the fence): filler prose with no numerals,
so Von's chain gate stays shut, long enough that Von middle-cuts it. At 06:05:23Z → 06:06:01Z Von cut a
14,014-token state to 8,171 tokens (its own `truncation`), ran one encoder pass of 8,184 tokens, and the
server's peak resident memory (`VmHWM`, its own PID) was **3,437 MB**, under the 8 GB cap with room; it
answered without error (`receipts/mem-probe-von-cpu.json`, `receipts/memprobe-von-cpu.log`). Laya's
longest input is 512 tokens and needs no probe. A Von bookkeeping detail seen here, recorded only: the
response's `questions_affected` reads 2 for one question, because the chain pre-check cuts the state too.

*DV-3, a dated note (06:07Z; a receipt, not a fix):* the fixed launcher was then run once for Laya the same
way (06:06:43Z → 06:07:03Z, no kit line). The server's own PID read 3,377 MB resident with both
checkpoints preloaded and a peak of 3,988 MB, under the cap. The 72,071-character filler was refused by
laya-serve's ceiling before any forward pass, `HTTP 413: {"detail":"state too large (72071 > 50000
chars)"}`, which is the refusal path DV1.5 records for the two long pages over 50,000 characters
(`receipts/mem-probe-laya-cpu.json`, `receipts/memprobe-laya-cpu.log`).

## Amendment DV-4: a chains-off companion for Von, the smoke's sixth line, the held-out digests' rule, the time box enforced, and a re-smoke (written 2026-10-01 06:27Z → 06:35Z; no counted row exists)

*Cold scroll: what this is.* The fourth amendment to this pre-registration (Von and Laya on the deciders bench,
exhibit sixty-six), written by the RUNS lane after the resume check (`SETUP.md` §7) and BEFORE any counted
call: `rows/` is empty, and no counted unit has run. The pushes so far, read again from GitHub's activity
API at 06:30Z: DV-1 `49afff91` at 05:52:05Z (it created the branch), DV-2 `86550def` at 06:03:56Z, DV-3
`a5b82b7d` at 06:06:25Z and DV-3's note `e8c03b2b` at 06:07:18Z. **No bar, prediction or reading of DV-1 to
DV-3 moves.** The authority is the go of D-20261001-022 and the standing overnight bench go D-20261001-009.

### DV4.1 Registered: a descriptive companion, Von with its chain engine OFF (VON-1-NOCHAINS)

- **Why.** DV-2's F-1: Von's chain-of-options engine is on by default, leaves no trace in the response, and by
  Von's own gate can act on 97 of 119 judge states and 5 of 53 long-page states (1 of 40 field-exam; none of
  the six-way, held-out or doorman states). So VON-1's judge figure reads the model AND its engine. A run
  with the engine off separates the two. It is registered now, before VON-1's judge rows exist, so the
  choice is not made after seeing them.
- **What runs.** Arm `von-cpu-nochains` (label `VON-1-NOCHAINS`): `von serve --host 127.0.0.1 --port 8031
  --device cpu --no-chains`, the vendor's own switch (von-sdk 1.3.5 `cli.py` sets `VON_CHAINS_DIR=off`, so the
  backend builds no chain runner). Everything else is VON-1's: the venv, weights and pins, the sandbox and its
  fence proof, the bodies (each hash-checked against Kev-9B's twin, the runner exits on a mismatch), the
  readout and the scoring. Its own scratch HOME. **Sets: the judge question (kj) and the long pages (ka)
  only**; the runner refuses any other set for this arm. Rows: `rows/von-cpu-nochains.kj.jsonl` and
  `rows/von-cpu-nochains.ka.jsonl`. It runs after LAYA-1, under the same launcher and time box (DV4.4).
- **What it may say: descriptive only.** Von's headline figures stay VON-1's, as shipped (chains on). No bar
  and no test attaches to the companion. It is read by the pinned table script (`--arm von-cpu-nochains`)
  and by one new read-only script, `instrument/chains_pair.py` (pinned in DV4.6), which joins the two Von
  arms by item id, splits the rows by Von's own gate, and counts: the same answer, a changed answer (by id),
  the 2 × 2 of right with the engine by right without, the page recount's exact McNemar p printed beside it
  and labelled descriptive, and the largest probability difference. Long pages are compared like with like
  only (whole in both runs, or cut in both; DV1.5).
- **Registered expectation.** On gate-shut rows the engine cannot act, and S-2 reproduced S-1 exactly, so the
  two runs give the same answer there. A changed answer on a gate-shut row is a finding, reported by id.
- **Predictions (80 % intervals, written before the companion's first call):**

| | VON-1-NOCHAINS |
|---|---|
| judge, strict, of 119 | 80 (55–100), level with VON-1's own prediction |
| changed answers vs VON-1, gate-open judge rows (97) | 15 (3–40) |
| changed answers vs VON-1, gate-shut judge rows (22) | 0 |
| long pages reached whole, of 53 | equal to VON-1's (the cut does not depend on the engine) |
| changed answers vs VON-1, gate-open long pages (5) | 1 (0–4) |

### DV4.2 A deviation, recorded: the smoke legs sent a sixth public line

run_kev's generators send an item's request when they are advanced, and the runner checked the smoke limit
only after advancing. So every smoke leg (S-1 and S-2, both arms) also sent six-way **c003** and dropped its
answer unread: each of the four server logs shows **12** requests against the **11** its rows account for
(3 six-way, 2 long pages, 6 orders of c000). The rows hold 5 lines, but each model was sent **6** distinct
public lines against DV1.6's cap of 5. Recorded, not re-run. The counted legs have no limit and are not
affected. **The fix** (an instrument change): the limit is applied with `itertools.islice`, which never
advances a generator past it. Bodies, calls, readout and scoring are unchanged.

### DV4.3 The held-out digests: DV-1's note corrected to the house's form

DV-1's INTERNAL note says H48 digests never appear "in any committed row". The runner DV-1 pinned writes each
kh row's `text_sha256` and `prompt_sha256` (as run_kev writes on every row), and SETUP's commit step commits
them. That is the house's form for held-out rows in the private record (APUS A-0: "no H48 line in any
committed file. Rows carry `text_sha256` and the compiled prompt's sha256 only"; imajev I-1 the same). The
note is corrected to that form, which is what runs: **no H48 line is in any committed file; the kh rows carry
those two digests in the private estate record only** (the repository is private); **no digest is printed**
in a log, a ROW or SUMMARY line, a table, this file, a kit or a page. The digests are kept rather than
stripped because `prompt_sha256` is how an independent check proves each kh body is task_kc's builder.

### DV4.4 The time box, enforced; the launcher, stated

Each counted leg runs in its own transient user unit (`systemd-run --user --unit=… --collect`) with
`MemoryMax=8G`, `MemorySwapMax=0`, `CPUAffinity=0-7` and now **`RuntimeMaxSec=7200`**, so DV1.6's 120-minute
stop holds even when no one is watching. If it trips, systemd stops the leg; the file without a summary is
renamed `.partial` (SETUP §7), and an amendment comes before anything resumes. A unit, not DV1.7's
`--scope`: a scope dies with the shell that started it (the sandbox runs `--die-with-parent`), and the house
runs long legs in units; the cgroup limits are the same, and DV-2 already recorded the unit as the counted
legs' launcher. None of this changes a body, call, readout or score.

### DV4.5 A re-smoke of the changed instrument (S-3), uncounted

Before VON-1: S-3 on `von-cpu`, `von-cpu-nochains` and `laya-cpu` with this amendment's instrument, through
the counted legs' launcher, into `rows-smoke/` (the S-2 files kept as `*.prior-<stamp>`). It sends the same 5
public lines as S-1 and S-2 (c000 to c002, on-03, on-04, and c000 under the six orders), so **no model is sent
a line it had not already been sent**. Its rows never count. Expected: `von-cpu` and `laya-cpu` equal S-2 row
for row; 11 requests in each server log, not 12; `von-cpu-nochains` equal to `von-cpu` on the gate-shut lines,
and on-03 (gate open; 2,852 state tokens, 49,852 input tokens with the engine) answered in ONE encoder pass.

### DV4.6 The instrument at this amendment

`run_deciders.py` (the companion arm; `is_von` so every Von arm reads Von's response fields and records its
gate; the islice fix; a counted leg refuses sets its arm is not registered for), `serve_and_run.sh` (the
`--no-chains` case, and an unknown arm now stops), `sandbox_deciders.sh` (the companion uses Von's venv), and
the new `chains_pair.py`. `tables_von_laya.py` is unchanged. Their sha256 are in `receipts/instrument.sha256`,
committed with this amendment. Run order from here: S-3 (three arms), then VON-1, LAYA-1 and VON-1-NOCHAINS,
one at a time, never two at once.

sha256 at this commit: `run_deciders.py` `<withheld: rewritten file, see README.md>`,
`serve_and_run.sh` `95a18cf823d374a4937e5c9dd6663d5c6f83298661b15d52c6626c951c967571`, `sandbox_deciders.sh`
`<withheld: rewritten file, see README.md>`, `chains_pair.py`
`3427383180143a7281bfa07db02c9a4ee18f98f98f25152463ec2fec9acbdac9`; `tables_von_laya.py` unchanged at
`<withheld: rewritten file, see README.md>`.

## VON-1 and LAYA-1 results (2026-10-01, pointer), the predictions scored, and the independent check's corrections (written 2026-10-01, 09:14Z to 09:16Z)

*Cold scroll: what this block is.* It points to the counted readings of the two models this file pre-registered:
Von 1.3 (`wfzyx/von` at `411c4440`) and Laya (`convaiinnovations/laya` at `55cf4c4e`). Each was asked the deciders
bench's five questions through its own server, on a laptop's processor, inside the fence. The counted legs ran from
**2026-10-01T06:40:48Z** (VON-1's fence proof) to **07:33:46Z** (VON-1-NOCHAINS's last row), and nothing was re-run.
The block scores DV1.11's and DV4.1's predictions. It also carries the independent check's corrections to DV1.5,
DV1.9 and DV-2's F-2, each dated, while DV-1 to DV-4 stay as written. This is the first reading of either model on
our kit. Beside the fourteen models the page read from 2026-09-13 to 2026-09-28, Von's six-way count equals the
lowest the page prints, Laya's is above only two rows, and both fail the door's gate.

**Where the figures are.**

- **Rows:** `rows/` at `6bb4c673`, pushed 07:34:56Z. **Tables:** `TABLES-von-laya.json` and `CHAINS-PAIR-von.json`
  at `a2c90bf0`, pushed 07:35:36Z, from the table script DV-2 pinned and DV-4's pairing script.
- **The reducer:** `reduce/reduce_von_laya.py` and its output `reduce/REDUCE-von-laya.json`, committed at `ad1af3ce`,
  the commit before this block. It loads the page's own recount, unedited and pinned in full, and re-runs it. The
  re-run equals the page's record on every key but `ref`. It then adds the two arms with the recount's own
  functions. Re-run from that path, both files come out byte for byte.
- **The check's figures:** `reduce/fold_von_laya.py` and `reduce/FOLD-von-laya.json`, at the same commit. They give
  the weight files' dates, read from Hugging Face's per-file history (the reads are in `reduce/weight-dates-reads/`,
  taken 09:02Z to 09:06Z), and each server's input cuts, read from its own response fields.
- **The results file and the check:** `RESULTS.md` in the lead's archive (`bench-archive/plans-2026-10-01/
  deciders-von-laya/`). It has every figure with its source key, the page placements and the caveats. The
  independent audit (`AUDIT.md`) and the page changes (`PAGE-CHANGES.md`) sit beside it. The audit re-derived each
  decision from the servers' raw responses with its own code: 358 figures compared, 358 equal.
- **What the kit may never carry:** `KIT-HOLD.md`, beside this file.

**The registered readings (DV1.8; the bars unchanged).** Sources are `REDUCE-von-laya.json` keys, with `<arm>` set
to `von-cpu` or `laya-cpu`.

| Reading | Von 1.3 | Laya | Source key |
|---|---|---|---|
| Six-way, right of 108 (Wilson 95 %) | 5 (2.0 to 10.4 %) | 19 (11.6 to 25.8 %) | `registered.arms.<arm>.s0` |
| The word counter's bar (68 of 108), two-sided exact McNemar | Behind: 1 line right only here, 64 only in the word counter; p 3.6e-18 | Behind: 2 against 51; p 3.2e-13 | `registered.mcnemar.<arm>\|naive-bayes` |
| The door's 09-13 gate (at least 30 of 36 planted refused and at most 2 of 12 harmless) | FAIL: 1 of 36 and 0 of 12 | FAIL: 31 of 36 and 12 of 12 | `registered.arms.<arm>.door` |
| Held-out, right of 48 | 5 | 8 | `registered.arms.<arm>.h48.k` |
| Six-way share minus held-out share, points (Newcombe 95 %) | −5.8 (−17.8 to +2.4) | +0.9 (−13.3 to +12.4) | `registered.arms.<arm>.s0_minus_h48` |
| Field exam, right of 40 | 29 | 35 | `registered.arms.<arm>.field.k` |
| Judge question, strict and any listed, of 119 | 58 and 58 | 56 and 60 | `registered.arms.<arm>.judge` |
| Long pages reached whole (DV1.5), of 53; right of those | 38; 26 | 0; none reached | `registered.arms.<arm>.long_pages` |
| Long pages answered on a cut page; right of those | 15; 9 | 51; 38 | The same |
| Long pages refused by the server | 0 | 2 (HTTP 413, over 50,000 characters) | The same, `refused_by_reason` |
| Six-way lines whose answer moved over Kev's six orders, of 108 | 0 | 52 | `registered.arms.<arm>.reorder.moved` |

**DV1.11 scored: 9 of the 16 interval predictions landed inside their 80 % intervals, and all 4 categorical
predictions held.**

| Quantity | Arm | Predicted | 80 % low | 80 % high | Measured | Inside |
|---|---|---:|---:|---:|---:|---|
| Six-way, right of 108 | Von 1.3 | 55 | 38 | 72 | 5 | No |
| Six-way, right of 108 | Laya | 35 | 20 | 55 | 19 | No |
| Held-out, right of 48 | Von 1.3 | 24 | 15 | 33 | 5 | No |
| Held-out, right of 48 | Laya | 16 | 8 | 26 | 8 | Yes |
| Field exam, right of 40 | Von 1.3 | 34 | 26 | 40 | 29 | Yes |
| Field exam, right of 40 | Laya | 30 | 20 | 39 | 35 | Yes |
| Judge question, strict, of 119 | Von 1.3 | 80 | 55 | 100 | 58 | Yes |
| Judge question, strict, of 119 | Laya | 60 | 35 | 90 | 56 | Yes |
| Long pages reached whole, of 53 | Von 1.3 | 38 | 30 | 45 | 38 | Yes |
| Long pages reached whole, of 53 | Laya | 2 | 0 | 6 | 0 | Yes |
| Six-way lines moved over six orders, of 108 | Von 1.3 | 0 | 0 | 3 | 0 | Yes |
| Six-way lines moved over six orders, of 108 | Laya | 25 | 8 | 50 | 52 | No |
| Door, should-refuse lines refused, of 36 | Von 1.3 | — | 10 | 32 | 1 | No |
| Door, should-refuse lines refused, of 36 | Laya | — | 5 | 30 | 31 | No |
| Door, harmless lines refused, of 12 | Von 1.3 | — | 0 | 6 | 0 | Yes |
| Door, harmless lines refused, of 12 | Laya | — | 0 | 9 | 12 | No |

The four categorical predictions: the door's gate FAIL for each model (both failed), Von level with or behind the
word counter and not ahead (behind, p 3.6e-18), and Laya behind it (behind, p 3.2e-13). Every miss points the same
way, toward a weaker decider than predicted: lower six-way and held-out counts, a door that admits nearly every line
(Von) or refuses nearly every line (Laya), and more movement under shuffling (Laya).

**DV4.1 scored (the chains-off companion, descriptive): 2 of the 3 interval predictions landed inside, and the point
and equality predictions held.** Sources are `TABLES-von-laya.json` and `CHAINS-PAIR-von.json`.

| Quantity | Predicted | Measured | Held |
|---|---|---:|---|
| Judge question, strict, engine off, of 119 | 80 (55 to 100) | 58 | Yes |
| Changed answers on the 97 gate-open judge rows | 15 (3 to 40) | 0 | No |
| Changed answers on the 22 gate-shut judge rows | 0 | 0 | Yes |
| Long pages reached whole, engine off | Equal to VON-1's (38) | 38 | Yes |
| Changed answers on the 5 gate-open long pages | 1 (0 to 4) | 3 | Yes |

**Corrections, dated 2026-10-01 (from the independent check).** None moves a figure, a bar or a registered reading,
and nothing was re-run.

1. **DV1.9, the weights' dates.** DV1.9 dated each model by its repository's last commit: "Von's weights were last
   modified 2026-09-30T03:48Z and Laya's 2026-09-24T05:39Z". Those commits changed only a README and an image. Read
   instead from each weight file's own history (Hugging Face's per-file `lastCommit` at the pinned revision;
   `FOLD-von-laya.json` `weight_dates`), the dates are these:
   - **Von.** `model.safetensors` (with `config.json` and the tokenizer files) was last changed 2026-09-24T00:59:00Z.
     `option_marker.pt` (the weights Von's server log says it loaded) and `marker_calibration.json` were last changed
     at 01:34:18Z. Both commits are titled "release: von-1.2.0 weights + calibration (independent_options)". At those
     commits, both weight files already had the exact bytes we pinned. So Von's weights postdate the six-way's public
     wall (2026-09-19) and the Reading the answer kit (2026-09-23T13:16:28Z), the kit by about 12 hours. They predate
     this page's own kit (poured 2026-09-30T02:37:00Z to 02:40:12Z) by about six days. The held-out lines remain the
     check that can see a kit advantage, and at Von's level it cannot see one: no held-out count would clear zero.
   - **Laya.** The English checkpoint, which answered all 522 counted rows, was last changed 2026-09-18T05:13:12Z
     ("Initial release"). That covers `model.safetensors`, its encoder config and its tokenizer files, and those are
     the bytes we pinned. That is 18 hours 46 minutes before the wall's date, taken as 2026-09-19T00:00:00Z under the
     cost series' R-1 date rule. On 2026-09-19 at 06:46:52Z the root `rl_agent_config.json` changed in one field
     only: the encoder's model id, from a local build path to `answerdotai/ModernBERT-large`. Its temperatures are
     unchanged. The multilingual and typed-decisions checkpoints (2026-09-19, 06:48Z) answered no row. So Laya's
     English checkpoint predates the wall. Its held-out reading (+0.9 points, −13.3 to +12.4) stands as printed.
2. **DV1.5 and DV-2's F-2, Laya's window.** "512 tokens with 192 for the question and options, about 320 for the
   state" read the code. The server does not split the window that way: it takes the question and the options, then
   as much of the state as fits in 512 tokens. Measured from its own response fields (`usage.truncated`,
   `usage.state_tokens`, `usage.state_tokens_dropped`; `FOLD-von-laya.json`, `input_cuts.arms.laya-cpu`):
   - **Long pages.** All 51 it answered were cut. It kept 443 to 465 tokens of each page (median 456), from pages
     1,732 to 12,599 tokens long (median 5,756), by its own tokenizer.
   - **The judge question.** Laya answered 107 of the 119 judge questions on a cut section, which no file reported
     before this check. It kept 316 to 367 tokens of each cut section (median 342), from sections 346 to 1,884
     tokens long (median 613). Scored strict, it got 49 of the 107 cut rows right and 7 of the 12 whole ones. DV1.5's
     "reached only when whole" rule is registered for long pages only. So the judge figures (56 strict, 60 any
     listed) stand as registered, and each is printed with this condition beside it.
   - **Von** cut no judge section and 15 long pages, each stated in its own `truncation` field.
3. **DV4.2, named again.** The smoke legs sent each model 6 public lines against DV1.6's cap of 5. DV4.2 recorded
   this before any counted call, and it touches no counted figure.
4. **The tables commit's note.** `a2c90bf0`'s note says the chain engine "moved probabilities on 97 judge rows". The
   rows show encoder passes added on 53 of the 97 gate-open rows, probabilities moved on 37, and no answer changed
   (`RUNS.md` §3).
5. **DV1.10's card.** DV1.10 names "the RTX 3090" without its partner and size. Any outward copy of this file names
   the card in the pen's form, "<partner> <name> <GB> GB" (D-20261001-003).
6. **The kit's copy of this file.** Amendment DV-2 prints the private recount's full digest, and the page's kit
   carries the pre-registrations. Its copy of this file must withhold that digest. `KIT-HOLD.md` lists every file
   that prints the digest, in full or in part, and the rest of what the kit may never carry.
7. **The kit's recount does not know the two arms.** The page says its kit's recount re-derives every count in the
   tables. For the two new rows, that holds only through `reduce/reduce_von_laya.py`, which needs the private copy.
   Until a kit version exists under the kit rules, the page qualifies that sentence for the two rows.

## Amendment DV-5: the speed leg, on benchbox's processor and its RTX 3090 at 300 W (written 2026-10-01 09:26Z → 09:28Z; no speed call exists)

*Cold scroll: what this is.* The fifth amendment to this pre-registration (Von and Laya on the deciders bench,
exhibit sixty-six, "Small open deciders, measured"). VON-1 and LAYA-1 measured accuracy on this laptop's processor
while that laptop was loaded (a load average near 15), so their times were kept as conditions and never published
(DV1.10). This amendment registers the speed leg DV1.10 promised: the same two models on the quiet bench box,
benchbox, on its processor and on its RTX 3090, timed the way the page timed its other small deciders. It is written
and pushed before any model call on benchbox. The push time is read from GitHub's activity API and recorded in
`receipts-speed/dv5-push.txt` with the first speed rows. **No bar, prediction or reading of DV-1 to DV-4, or of the
results block above, moves, and no accuracy figure comes from this leg.**

*The authority.* an operator's go of D-20261001-022 (2026-10-01T05:31:52Z, verbatim in DV-1), then, in the same
session, "so hopefully we can keep that goal to have these 2 models added to this bench by tomorrow sometime?"
and "if we can prioritize this overnight too". The standing overnight bench go is D-20261001-009. D-20261001-028
runs this leg on benchbox ahead of arm C's window, under the lock word `dv-speed`.

*What ran on benchbox before this push, none of it a model call* (UTC, `date -u` on each box): the box read at
09:04Z (idle, load 0.00, no `/workshop/CARD-LOCK`, the card at 1 MiB, 300.00 W, persistence Enabled, no compute
process); the interpreter's copy (09:17Z); the weights' copy and their hashes on both boxes (09:18:08Z →
09:19:17Z); the instrument's copy, equal on both boxes; the four venvs (09:20:19Z → 09:20:32Z); the fence proofs
(09:21:52Z → 09:21:53Z); the no-call preflight of every arm (09:22:30Z → 09:22:35Z); and a self-test of the stop
guard against a card name that does not exist (09:22:46Z: it read the UPS, tripped on its own sampler, and had
nothing to stop). The card was read by `nvidia-smi` queries and never used. The receipts are
`receipts-speed/stage-*` and `receipts-speed/fence-stage-*`.

### DV5.1 The question: a speed reading, not an accuracy reading

What does each model take to run, as shipped, one request at a time? The figures are the median seconds a six-way
line, its p90 and p95, and the memory each holds, on benchbox's processor and on benchbox's RTX 3090 at 300 W. These
are what exhibit sixty-six prints for its other small deciders: its "What it takes to run" section (the median per
six-way line in seconds; on a card, what grew at load and the highest reading, in MiB of 24,576), and the tables
behind it (EVIDENCE-v2 table 9, the median and the p95 by nearest rank per S0 item, one request at a time; table
9b, memory on one 24 GB card). Accuracy stays VON-1's and LAYA-1's. Nothing here is scored against a bar.

### DV5.2 The box, the processor, the card and its cap

| | |
|---|---|
| box | benchbox, the bench box (D-20260918-10): Ubuntu 26.04 LTS, kernel 7.0.0-31-generic, x86_64, 30 GiB of memory; NVIDIA driver 595.84 (its CUDA 13.2); the rack UPS on NUT (`pr1500`), read at 09:04Z on line, charge 100 %, runtime 5,525 s, load 6 % |
| processor | **AMD Ryzen 7 3700X 8-Core Processor**: 8 cores and 16 threads (CPUs 0–7 are one thread on each core, 8–15 their SMT siblings), AVX2, the schedutil governor with boost on, as the box runs |
| card | **EVGA GeForce RTX 3090 XC3 Ultra 24 GB** (24,576 MiB). It is the page's **card B**: its UUID fingerprint equals the one L-2 and O-2 recorded for card B (read on the box between 09:04Z and 09:06Z). The runner checks this again before every GPU arm and writes only the verdict |
| the cap | **300.00 W** (default 350, maximum 366), persistence Enabled. This is the cap of every card-B row on the page (O-2, L-2, A-1, A-1b, I-2, arm 13). The leg never changes it, and an arm refuses a card that does not read 300.00 W (DV5.6) |

### DV5.3 The runtimes, as shipped, each device named

| arm (label) | device | the server, from its own CLI | precision, as shipped | torch | threads, CPUs |
|---|---|---|---|---|---|
| `speed-von-cpu` (SPEED-VON-CPU) | the processor | `von serve --host 127.0.0.1 --port 8031 --device cpu` | fp32: von-sdk casts nothing, and the checkpoint is F32 | 2.14.1+cpu | 8, CPUs 0–7 |
| `speed-laya-cpu` (SPEED-LAYA-CPU) | the processor | `laya-serve` with `LAYA_DEVICE=cpu` | fp32: `LAYA_CPU_AMP` unset, laya's CPU default | 2.14.1+cpu | 8, CPUs 0–7 |
| `speed-von-gpu` (SPEED-VON-GPU) | the card | `von serve --host 127.0.0.1 --port 8031 --device cuda` | fp32: von-sdk casts nothing | 2.14.1+cu130 | 7, CPUs 1–7 |
| `speed-laya-gpu` (SPEED-LAYA-GPU) | the card | `laya-serve` with `LAYA_DEVICE=cuda` | bf16 autocast: laya's CUDA default, the checkpoint's `amp_dtype` at compute capability 8.6 (`LAYA_CUDA_AMP` unset); its TileLang fast path off (`fast=False`, as shipped) | 2.14.1+cu130 | 7, CPUs 1–7 |

Every other server setting is DV1.3's. Laya runs with `LAYA_PRELOAD=1 LAYA_MODELS=english,multilingual
LAYA_REVISION=reviewed` and its Router auto-routing. Von runs with its defaults, its chain engine on. The engine
never opens on a six-way line (DV-2's F-1: 0 of 108 by Von's own gate), so each Von six-way line is one encoder
pass.

- **The processor arms run the accuracy legs' runtime, and NOT Von's fastest processor path. Registered now.**
  Von's card quotes its CPU speed on OpenVINO ("0.096 s raw p50 on 4 vCPU (OpenVINO …)", at `411c4440`), and
  von-sdk's own auto-selector prefers OpenVINO on a processor when it is installed. This leg times torch fp32
  (`--device cpu`), matching VON-1 (DV1.3). **OpenVINO is neither installed nor imported:** `import openvino`
  sends a Google Analytics event unless a consent file says no (DV1.7; `SETUP.md` §2 and §5, finding 4). The runner
  checks every venv for its absence before each arm. So the processor row reads "torch fp32 on the processor",
  never "Von's CPU speed", and the vendor's figures stay quoted.
- **The card arms' torch build is a named deviation.** The CPU locks pin `torch==2.14.1+cpu`, which cannot reach a
  card. The card venvs come from `instrument/speed/lock/{von,laya}-cu130.lock.txt`. Each is its CPU lock with
  torch's build swapped to `2.14.1+cu130` (the same release, CUDA 13.0) and torch's 19 CUDA dependencies added:
  `cuda-bindings`, `cuda-pathfinder`, `cuda-toolkit`, 15 `nvidia-*` wheels and `triton`. Every other package equals
  the CPU lock in version and hash: 44 of 45 for Von and 43 of 44 for Laya, torch the one change
  (`instrument/speed/lock/lock-diff.json`). Both were compiled with `uv pip compile … --torch-backend cu130
  --generate-hashes`, constrained to the CPU locks' pins.
- **The card arms use the house's form for card B:** `TORCH_DISABLE_NATIVE_JIT=1` and 7 threads under
  `taskset -c 1-7`, as every card-B row on the page ran (O-2 amendment v1, L-2, A-1, I-2). torch stays on its stock
  ATen kernels.
- **The precision differs from the page's other card rows, and every row names it.** The page's other small
  deciders ran in bf16 on the card. Von, as shipped, runs fp32 on CUDA, because it casts nothing; Laya autocasts
  to bf16. Neither is changed to match, because "as shipped" is the rule (DV1.1).

### DV5.4 Weights, interpreter, venvs and instrument: copied and checked, with nothing fetched from Hugging Face on benchbox

- **The weights.** this laptop's pinned HF cache (`hub/`: both repositories at their pins, with `refs/main`) went to
  benchbox by rsync over ssh (09:18:08Z → 09:18:58Z). All 27 files of `receipts/weights.sha256` were hashed on both
  boxes. this laptop's hashes equal the 05:44Z fetch receipt, benchbox's equal this laptop's, and both boxes' `refs/main`
  equal the pins (`receipts-speed/stage-weights.sha256`). Each arm re-hashes its repository's files before its
  server starts, and the runner stops on a mismatch.
- **The interpreter.** The accuracy legs' CPython 3.13.14 (uv-managed) went over as one tarball, sha256
  `b9c3141f…` on both boxes (`receipts-speed/stage-interpreter.txt`).
- **The venvs.** All four were built on benchbox with uv 0.12.7 (this laptop's used 0.11.27), by
  `uv pip install --require-hashes --no-deps`. `venv-von-cpu` and `venv-laya-cpu` come from the unchanged
  `instrument/von.lock.txt` and `instrument/laya.lock.txt` (`--torch-backend cpu`). `venv-von-cu130` and
  `venv-laya-cu130` come from the cu130 locks (`--torch-backend cu130`). `uv pip check` is clean on all four, and
  **the two processor venvs' freezes equal this laptop's line for line** (`receipts-speed/stage-freeze-*`).
- **The instrument.** These went to benchbox: arm 12's `run.py`, `run_kev.py` and `run_addenda.py` (unedited, at
  DV-1's digests), `hostos.py`, this arm's `run_deciders.py` (unedited, at DV-4's `<withheld: rewritten file, see README.md>…`), `fence_probe.py`,
  `pins.json`, and the public items the six-way needs (`kit/task_c.json`, `kit/manifest.json`, Kev-9B's
  `kev-9b.kc.jsonl`, and arm 2's two public long-page row files, which `run_addenda` reads when it is imported).
  **No held-out, doorman, field-exam or judge file went to benchbox.** Every copy equals its original
  (`receipts-speed/stage-instrument.sha256`).
- **New in this commit** (`instrument/speed/`, sha256 in `receipts-speed/instrument-speed.sha256` and DV5.11):
  `speed_deciders.py` (the runner); `serve_speed.sh` (inside the sandbox: the fence proof, the card's reading before
  any server, the server, then the runner); `sandbox_speed.sh` (the fence); `unit_speed.sh` (the unit body, outside
  the sandbox); `guard_speed.py` and `guard_unit.sh` (the stop guard); `lock_take.sh`, `lock_gate.sh` and
  `lock_release.sh` (the card lock); `tables_speed.py` (the table script, pinned now); and `lock/` (the cu130 locks,
  their constraints and inputs, and `lock-diff.json`).

### DV5.5 The fence, the lock and the stop

- **The fence** is DV1.7's, moved to benchbox (`sandbox_speed.sh`). It is bwrap with `--unshare-net` (only `lo`),
  new pid, ipc and uts namespaces and `--clearenv`. The filesystem is read-only. `/home` is a tmpfs that shows only
  these: read-only, the venv, the HF cache, the interpreter, the instrument's copy and the guard's heartbeat folder;
  writable, the rows, the receipts and the arm's scratch HOME. Server and client share one sandbox. Processor arms
  get no card node and `CUDA_VISIBLE_DEVICES=""`. Card arms get the four NVIDIA device nodes, with the card's UUID
  in the environment only. The switches are the house list, and `DO_NOT_TRACK` is never set.
- **The fence's proof runs before every server start** (`fence_probe.py`, unchanged): planted connects to
  1.1.1.1:443 and 8.8.8.8:53 must fail, `huggingface.co` must not resolve, loopback must connect, and the interfaces
  must be `lo` alone, or the arm stops. **It was staged at 09:21:52Z with a positive control.** Outside the sandbox,
  on the same box, the same probe CONNECTED to both addresses and resolved `huggingface.co`. Inside each of the four
  sandboxes it read "Network is unreachable" twice, the name unresolved, loopback connected and `["lo"]`
  (`receipts-speed/fence-stage-*.json`).
- **The card lock** uses the house's scripts with the word `dv-speed` (`lock_take.sh`, `lock_gate.sh`,
  `lock_release.sh`), with one change for the pen: the compute-process query never asks for the UUID. **The lock
  is taken BEFORE the dry run, because the dry run uses the card**, and it is held through every timed arm, so arm
  C's lanes, which read `/workshop/CARD-LOCK`, wait. Every arm's unit body runs the gate first. If `/workshop/CARD-LOCK` is present
  and not ours, the lane stops. The lock is released at the end, even after a failure, only when the card is empty
  at its posture (1 MiB, 300.00 W, persistence Enabled, no compute process, no `dv-speed-*` unit). The card is read
  after the release (expect 1 MiB).
- **The stop guard** (`guard_speed.py`, its own user unit, outside the sandbox) is I-2's guard with benchbox's kit's
  UPS rules added. Every second it reads the UPS, the free disk and the card's posture, and it samples the card at
  2 Hz by UUID. **It stops every dv-speed arm when any of these happens:** the UPS reads OB (on battery); the UPS
  reads LB (low battery); the UPS is unreadable on 3 reads in a row; the UPS runtime reads under 300 s on 3 reads in
  a row; the UPS load reads 80 % or more; the card core reads 83 C or more; the free disk falls under 15 GiB; or its
  card sampler exits. A trip is recorded first, and it is a finding. The unit body refuses to start an arm unless
  the guard's heartbeat is under 10 s old and the UPS reads on line with at least 300 s of runtime.
- **The units.** Each arm runs as `systemd-run --user --unit dv-speed-<dry|timed>-<arm> --collect -p MemoryMax=16G
  -p MemorySwapMax=0 -p RuntimeMaxSec=<900 dry, 1800 timed>`, and the guard with `-p MemoryMax=1G
  -p RuntimeMaxSec=7200`. One arm runs at a time, never two.
- **No sudo.** Nothing here needs it. A need for it would become a paste in the lane's report.

### DV5.6 The protocol (per arm: one sandbox, one server)

1. **The unit body:** the lock's gate; the card's posture read on the host (at most 50 MiB, 300.00 W, Enabled, no
   compute process), or the arm is REFUSED; the guard's heartbeat and the UPS, or REFUSED.
2. **Inside the sandbox:** the fence's proof; the card's reading before any server (card arms: `memory.used` by
   UUID, and card B by fingerprint at 300.00 W, or the arm stops); then the server, from its own CLI.
3. **The runner's checks:** the pins (every weight file, the three public items, arm 12's instrument, the package
   and torch builds, and OpenVINO, its telemetry package and onnxruntime absent); the 108 six-way bodies rebuilt
   with no call, each equal to Kev-9B's twin; the guard's heartbeat under 10 s old; then `/health`.
4. **Three discarded warm-up requests,** each c000's body (task (c) item 0; arm 12's practice, as in L-2). They
   are never rows. Von loads its model lazily on the first request, so its first warm-up includes the load.
5. **Where it computes, checked.** A card arm must have grown the card by at least 1,000 MiB. Laya's `/health` must
   name the arm's device on every checkpoint, with no CPU fallback. Von's banner must name CUDA or the CPU, when its
   log holds it yet. Otherwise the arm stops.
6. **The timed set is S0, the 108 six-way lines** (`kc`, public), sent through `run_kev.task_kc` unedited, one
   request at a time, in kit order. Every row's `prompt_sha256` must equal Kev-9B's twin, or the runner exits.
   **`seconds` is `run_kev.kev_decide`'s own timer:** the client's wall time for one HTTP round trip over loopback,
   the same timer as the page's Kev and Lev rows (its other rows used their own harnesses, in-process or not).
7. **The repeats are three passes,** back to back, into `rows-speed/<arm>.kc.rep{1,2,3}.jsonl`. **The headline is
   pass 1**, the page's form (one pass of 108 lines after three warm-ups). Passes 2 and 3 and the pooled 324 rows are
   printed beside it, never instead of it.
8. **The longest input,** after the timed passes so it cannot disturb them. It is DV-3's probe: filler prose with
   no kit line and no numerals, so Von's chain gate stays shut. Von gets DV-3's exact filler (13,013 words, 72,071
   characters), which it middle-cuts from 14,014 tokens to its 8,192-token window. Laya gets the same filler at
   6,513 words (36,071 characters, under laya-serve's 50,000-character ceiling), which it cuts to its 512-token
   window. A refusal here stops the arm, and it is a finding.
9. The server is stopped, and the unit body reads the card's posture again.

**The figures, and how each is read (the page's definitions):**

| figure | how it is read |
|---|---|
| median seconds a six-way line | the median of pass 1's 108 `seconds` |
| p90 and p95 | nearest rank over the same 108 values: `sorted[round(q·(n−1))]`, R.summarise's p95 form (the page's "p95 s (nearest rank)") |
| grew at load, MiB (card) | `memory.used` after the warm-ups minus the reading before the server started, both by the card's UUID inside the sandbox (the page's table 9b, "growth") |
| highest, MiB of 24,576 (card) | the highest 2 Hz `memory.used` sample in the arm's window, from the reading before its server to its summary's end, in the guard's telemetry outside the sandbox (table 9b, "highest"); with the headroom to 24,576 |
| peak memory (processor) | the server's own peak resident memory, `VmHWM` by its PID (DV-3's reading), after the longest input; also read after the warm-ups and at the end of pass 1 |
| device and cap | named in every row: the processor by its model, or the card by its partner's name, with the power limit read at the start |

**Readings added, descriptive (no bar).** Each pass's answers are set against VON-1's and LAYA-1's rows on the
same 108 lines: the count with the same choice, of 108, and the largest probability difference. The bodies are
byte-equal, so a different answer means different numerics (device, precision or kernels), not a different
question. The load time (`/health` ready, and the warm-ups' seconds) and the longest input's seconds are kept as
conditions.

### DV5.7 The dry run (uncounted), then the timed arms

- **The order.** Take the lock. Start the guard (`dv-speed-guard-dry`). Dry-run `speed-von-cpu`, `speed-laya-cpu`,
  `speed-von-gpu` and `speed-laya-gpu`, one at a time: steps 1 to 9 with **the first 5 six-way lines sent once**
  (c000 to c004, public lines every model here has already been sent) and then the longest input, into
  `rows-speed-dry/`. Dry rows never count, and their seconds are never published. Then the guard is restarted as
  `dv-speed-guard-timed`, and the timed arms run in the same order.
- **A refusal is a finding.** A stop, a refused arm or a trip is recorded and reported, and never re-run to a pass.
  A fix to the instrument is a commit plus a numbered amendment (DV-6), pushed before the next timed call. A timed
  file is never overwritten.
- **The time box.** Each dry arm gets at most 15 minutes and each timed arm at most 30 (`RuntimeMaxSec`). About 3
  minutes per processor arm and 1 per card arm are expected.

### DV5.8 Predictions (written before the first call on benchbox; 80 % intervals)

For reference, the laptop's loaded medians (conditions, never results) were 0.261 s for Von and 0.372 s for Laya a
six-way line (VON-1, LAYA-1).

| | Von, processor | Laya, processor | Von, card | Laya, card |
|---|---|---|---|---|
| median s a six-way line, pass 1 | 0.30 (0.15–0.60) | 0.40 (0.20–0.80) | 0.030 (0.012–0.080) | 0.030 (0.012–0.080) |
| p95 divided by the median, pass 1 | 1.5 or less | 1.5 or less | 2 or less | 2 or less |
| grew at load, MiB | — | — | 2,000 (1,600–3,200) | 3,300 (2,800–4,800) |
| highest, MiB, with the longest input | — | — | 4,500 (2,200–12,000) | 3,500 (2,900–5,500) |
| server VmHWM, MB, after the longest input | 3,450 (3,000–4,500) | 4,000 (3,500–4,800) | — | — |
| same choice as the accuracy leg, of 108, pass 1 | 108 | 108 | 108 (104–108) | 105 (95–108) |
| pass 3's median within 10 % of pass 1's | yes | yes | yes | yes |

### DV5.9 What this leg may and may not say

- **May:** each figure with its device, precision, runtime, threads and cap named, beside the page's other small
  deciders under "What it takes to run": Von and Laya on card B at 300 W, and on a desktop processor in torch fp32.
- **May not:** call a Von processor figure its fastest CPU path (OpenVINO is not timed); divide a card figure by one
  taken at another precision, card or cap without naming the difference (the page's own rule: "each row is its own
  runtime and card: divide none by another"); compare benchbox's processor with this laptop's from these rows (the
  laptop's were loaded); speak of throughput, batching or concurrency (one request at a time only); or move any
  accuracy figure.

### DV5.10 Not run, named

OpenVINO (the CPU route Von's card quotes); Laya's TileLang fast path (`laya[fast]`) and `torch.compile`; bf16 for
Von and fp32 for Laya on the card (neither is as shipped); any batched or concurrent request; Von's bundling of
several questions per request; timing on any set but the six-way (the judge question's chain passes and the long
pages stay conditions of the laptop legs); and energy per decision (the guard's telemetry records the card's draw,
but no energy figure is registered).

### DV5.11 The instrument at this amendment

sha256 at this commit: `speed_deciders.py` `<withheld: rewritten file, see README.md>`,
`serve_speed.sh` `cea8c03bfda04c1bb1a1a6e7d9569a29c1eade0230ffad97ad26073bae320490`, `sandbox_speed.sh`
`<withheld: rewritten file, see README.md>`, `unit_speed.sh`
`<withheld: rewritten file, see README.md>`, `guard_speed.py`
`<withheld: rewritten file, see README.md>`, `guard_unit.sh`
`<withheld: rewritten file, see README.md>`, `lock_take.sh`
`<withheld: rewritten file, see README.md>`, `lock_gate.sh`
`<withheld: rewritten file, see README.md>`, `lock_release.sh`
`<withheld: rewritten file, see README.md>`; **the table script, pinned before any speed row
exists:** `tables_speed.py` `<withheld: rewritten file, see README.md>`; the cu130 locks
`von-cu130.lock.txt` `2c677a0adf2058550ca084b867039030d93748d8acc31e0221b524606d84074e` and `laya-cu130.lock.txt`
`63ecd61808d1976006a31f6a88707f95fb45ff591b7ede3cb89f1e5c0c3a0ae6`. Unchanged: `run_deciders.py` `<withheld: rewritten file, see README.md>…`,
`fence_probe.py` `e0fef098…`, `pins.json` `<withheld: rewritten file, see README.md>…`, `von.lock.txt` `9dc748e2…`, `laya.lock.txt` `a4e1984c…`.

## Amendment DV-6: the dry run, read, and one fix to the speed leg's table script (written 2026-10-01 09:34Z → 09:36Z; no timed speed row exists)

*Cold scroll: what this is.* The sixth amendment, written after DV-5's uncounted dry run on benchbox and before any
timed speed call. DV-5 (commit `4063ba67`) was pushed at **2026-10-01T09:28:30Z**, read from GitHub's activity API
(`receipts-speed/dv5-push.txt`); the first model call on benchbox came after it. **No body, call, timer, set, pass,
bar or prediction of DV-5 moves.** One pinned script changes, the table script, before any row it reads exists.

**The dry run (uncounted; `rows-speed-dry/`; its seconds are never published).** The lock was taken at 09:28:41Z
(`dv-speed 2026-10-01T09:28:41Z`; the card read 1 MiB, 300.00 W, Enabled, no compute process) and the guard
`dv-speed-guard-dry` started at 09:28:50Z. Each arm ran as DV5.7 says, one at a time:

| arm | unit window (UTC) | what it showed |
|---|---|---|
| `speed-von-cpu` | 09:28:59 → 09:29:43 | fence held; pins and 108 of 108 bodies equal; Von's banner "von-1.3 on CPU"; the longest input cut from 14,014 to 8,171 tokens and read in one 8,184-token pass |
| `speed-laya-cpu` | 09:29:52 → 09:30:10 | fence held; pins and bodies equal; `/health` cpu on both checkpoints, no fallback; the longest input cut to 512 tokens (7,014 state tokens, 6,538 dropped) |
| `speed-von-gpu` | 09:30:38 → 09:30:54 | fence held; pins and bodies equal; banner "von-1.3 on NVIDIA GPU [CUDA: NVIDIA GeForce RTX 3090]"; the card grew 3,527 MiB; the longest input as on the processor |
| `speed-laya-gpu` | 09:31:24 → 09:31:39 | fence held; pins and bodies equal; `/health` cuda on both checkpoints, no fallback; the card grew 4,073 MiB; the longest input cut to 512 tokens |

On all four, the answers to c000 to c004 equal VON-1's and LAYA-1's (largest probability difference: 0 for Von on
both devices, 0.0001 for Laya on the processor, 0.0048 for Laya on the card); every unit exited 0; the card read
1 MiB, 300.00 W, Enabled and no compute process before and after each arm; the guard never tripped; and the servers
logged no warning but Laya's known temperature clamp (DV-2's F-4) and Von's tokenizer note on the 14,014-token
input.

**The finding, and the fix.** `tables_speed.py` read each card arm's highest from the guard's telemetry between the
reading before the server and the summary's `ended` stamp. The runner's stamps are whole seconds, truncated, and the
server stays up through that last second. On the dry data, Laya's card highest therefore read 3,232 MiB against the
runner's own 4,074 MiB after the warm-ups and 4,094 MiB after the longest input. **The fix:** the window runs to the
end of the summary's last second (the next arm starts later), and the script now prints the runner's own card
readings beside the highest, with a flag if any of them exceeds it. It also adds, for the processor arms, what the
card held during their passes (expect the idle 1 MiB). Re-run on the dry data: Laya's card highest reads 4,094 MiB,
Von's 4,618 MiB, with no flag; the processor arms' card reads 1 MiB throughout. `tables_speed.py` sha256 at this
commit: `<withheld: rewritten file, see README.md>`. Every other DV-5 file is unchanged
(`receipts-speed/instrument-speed.sha256`).

**Next, unchanged:** the guard is restarted as `dv-speed-guard-timed`, and the four timed arms run in DV5.7's order.

## DV-5 results (2026-10-01, pointer) and the predictions scored (written 09:45Z → 09:48Z, after the tables were drawn)

*Cold scroll: what this block is.* It points to the speed readings DV-5 registered: Von 1.3 and Laya, each as
shipped, one six-way line at a time, on benchbox's AMD Ryzen 7 3700X 8-Core Processor and on its EVGA GeForce RTX
3090 XC3 Ultra 24 GB at 300 W. The four timed arms ran from **2026-10-01T09:35:00Z to 09:42:54Z** (UTC), one at a
time, under the card lock `dv-speed` (taken 09:28:41Z, released 09:43:30Z), after the dry run (09:28:59Z →
09:31:39Z) and DV-6 (pushed 09:34:33Z). Nothing was re-run, the guard never tripped (UPS on line on all 471 timed
reads, runtime never under 1,075 s, the card's core never above 42 C), and every unit exited 0. These are the first
speed readings of either model on our kit. The accuracy readings above are untouched.

**Where the figures are.** Rows `rows-speed/` and receipts `receipts-speed/` at `4eb93e88`, pushed 09:44:26Z.
`TABLES-speed-von-laya.json`, beside this file and in the same commit as this block, drawn by the pinned table
script (`tables_speed.py` at DV-6's `<withheld: rewritten file, see README.md>…`), every file cited at `4eb93e88`. The lead's archive holds
`SPEED.md`, with each figure's source.

**The readings (pass 1, the registered headline; one request at a time, `run_kev.kev_decide`'s timer):**

| Model, device | Precision and runtime | Median s a six-way line | p90 s | p95 s | Passes 2 and 3, median s | Memory |
|---|---|---:|---:|---:|---|---|
| Von 1.3, AMD Ryzen 7 3700X 8-Core Processor (8 threads, one per core) | fp32, torch 2.14.1+cpu, `von serve --device cpu` | 0.4207 | 0.5044 | 0.5168 | 0.4247, 0.4150 | the server's peak resident memory 3,468 MB |
| Laya, AMD Ryzen 7 3700X 8-Core Processor (8 threads, one per core) | fp32, torch 2.14.1+cpu, `laya-serve` | 0.4355 | 0.4689 | 0.4753 | 0.4360, 0.4390 | the server's peak resident memory 4,019 MB |
| Von 1.3, EVGA GeForce RTX 3090 XC3 Ultra 24 GB at 300 W | fp32, torch 2.14.1+cu130, `von serve --device cuda` | 0.0190 | 0.0227 | 0.0229 | 0.0189, 0.0189 | grew 3,527 MiB at load; highest 4,618 MiB of 24,576 (19,958 of headroom), at its longest input (8,184 tokens) |
| Laya, EVGA GeForce RTX 3090 XC3 Ultra 24 GB at 300 W | bf16 autocast, torch 2.14.1+cu130, `laya-serve` | 0.0202 | 0.0205 | 0.0207 | 0.0201, 0.0200 | grew 4,073 MiB at load; highest 4,094 MiB of 24,576, at its longest input (512 tokens) |

- **Laya's highest, on the card:** the 2 Hz telemetry's highest in its window was 4,074 MiB, and the runner's own read
  after the longest input was 4,094 MiB, so DV-6's flag fired (the server exited before a 2 Hz sample caught the last
  20 MiB). The higher reading is the one printed, with both in the table file.
- **The same answers as the accuracy legs:** in every pass of every arm, 108 of 108 lines got the same choice as
  VON-1 or LAYA-1 on this laptop's processor. The largest probability difference was 0.0001 on three arms and 0.0656 for
  Laya on the card (bf16). Each pass read Von right on 5 of 108 lines and Laya on 19, as the accuracy legs did.
- **Each Von six-way line was one encoder pass**, its chain gate shut (DV-2's F-1): a median of 237.5 input tokens a line (131 to 305).
  Laya routed every line to its English checkpoint, and none was cut.
- **Conditions, not results:** the servers answered `/health` in 5.0 s (Von, processor), 9.1 s (Laya, processor),
  6.5 s (Von, card) and 9.6 s (Laya, card). Von loads its model on the first request, so its first warm-up took 1.9 s
  on the processor and 3.0 s on the card. The longest input took 29.9 s (Von, processor), 0.92 s (Laya, processor),
  1.63 s (Von, card) and 0.035 s (Laya, card); the processor arms left the card at 1 MiB throughout.

**DV5.8 scored: 11 of the 12 interval predictions landed inside their 80 % intervals, and all 10 point and
categorical predictions held.**

| Quantity | Arm | Predicted | 80 % low | 80 % high | Measured | Inside |
|---|---|---:|---:|---:|---:|---|
| Median s a six-way line, pass 1 | Von, processor | 0.30 | 0.15 | 0.60 | 0.4207 | Yes |
| Median s a six-way line, pass 1 | Laya, processor | 0.40 | 0.20 | 0.80 | 0.4355 | Yes |
| Median s a six-way line, pass 1 | Von, card | 0.030 | 0.012 | 0.080 | 0.0190 | Yes |
| Median s a six-way line, pass 1 | Laya, card | 0.030 | 0.012 | 0.080 | 0.0202 | Yes |
| Grew at load, MiB | Von, card | 2,000 | 1,600 | 3,200 | 3,527 | No |
| Grew at load, MiB | Laya, card | 3,300 | 2,800 | 4,800 | 4,073 | Yes |
| Highest, MiB | Von, card | 4,500 | 2,200 | 12,000 | 4,618 | Yes |
| Highest, MiB | Laya, card | 3,500 | 2,900 | 5,500 | 4,094 | Yes |
| Server peak resident memory, MB | Von, processor | 3,450 | 3,000 | 4,500 | 3,468 | Yes |
| Server peak resident memory, MB | Laya, processor | 4,000 | 3,500 | 4,800 | 4,019 | Yes |
| Same choice as the accuracy leg, of 108 | Von, card | 108 | 104 | 108 | 108 | Yes |
| Same choice as the accuracy leg, of 108 | Laya, card | 105 | 95 | 108 | 108 | Yes |

The point and categorical predictions: p95 over the median at most 1.5 on the processor (Von 1.23, Laya 1.09) and
at most 2 on the card (Von 1.21, Laya 1.02); 108 of 108 the same on the processor for both; pass 3's median within
10 % of pass 1's on all four arms (−1.4 %, +0.8 %, −0.3 % and −0.9 %, from the unrounded medians). The one miss is Von's growth on the card,
predicted from its fp32 weights (about 1.5 GiB) and a CUDA context: it grew 3,527 MiB.

**A dated note on DV-6's header.** It says "written 2026-10-01 09:34Z → 09:36Z". The amendment was pushed at
09:34:33Z (`a20a8d8a`), so it was written from 09:33Z to 09:34Z. Nothing else in it changes.

**A dated note on Laya's highest reading on the card (written 2026-10-01, 11:06Z to 11:07Z UTC, from the independent
speed check, `SPEED-CHECK.md` in the lead's archive, its C-1).** The figure is the most memory Laya's server held on
card B in its timed arm: the top 2 Hz telemetry sample (`receipts-speed/timed-telemetry.jsonl`) in DV-6's window,
which runs from the card's reading before the server (09:42:33Z) to the end of the summary's last second
(09:42:52.000Z). The first bullet under the readings above gives the wrong reason for the window's 4,074 MiB: the
server did not exit before a sample caught the last 20 MiB. The telemetry read 4,094 MiB at 09:42:52.092Z, 0.092 s
after the window closed, while the server still held the card, and 1 MiB at its next sample, 09:42:52.592Z. Against
the block above, no figure moves: 4,094 MiB, the arm's highest, read by the runner after the longest input
(`probe.card_after`, 09:42:51Z) and by that telemetry sample, is the figure printed; `TABLES-speed-von-laya.json`
keeps 4,074 MiB as the registered window's figure, with DV-6's flag; and DV5.8's interval for it (2,900 to 5,500
MiB) holds either way. For a next leg, the window ends at the first idle sample after the arm, not at a stamp
truncated to the second.

**A dated note on the memory unit (written 2026-10-01, 11:07Z to 11:08Z UTC, from `SPEED-CHECK.md`'s C-2 and the
unit note in `RESULTS.md`, both in the lead's archive).** The figures this file labels "MB" are a server's resident
memory, its peak (`VmHWM`) or its current size (`VmRSS`), read from `/proc/<pid>/status` by the server's own PID.
`run_deciders.proc_mb` divides the kernel's kB, which are units of 1,024 bytes, by 1,024, so each one is in MiB, not
MB. The labels concerned: DV-3's window probe, 3,437 (Von 1.3); DV-3's dated note, 3,377 resident and a peak of
3,988 (Laya); DV5.8's prediction row "server VmHWM, MB"; and the DV-5 results block's 3,468 and 4,019 and its two
"Server peak resident memory, MB" rows. Read each as MiB: 3,468 MiB is about 3.64 GB, and 4,019 MiB about 4.21 GB.
DV-3's "8 GB cap" is systemd's `MemoryMax=8G`, which counts in 1,024s, so 8 GiB (8,192 MiB). Against the text above,
no number changes and nothing was re-run: DV5.8's predictions were written in the same unit as the readings, so
their scoring holds, and every reading is under the cap either way. The registered text above is left as written.
