Site: readable charts, tables and model pages on every width

site/content/library/clef.md

@@ -22,10 +22,10 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `clef
 
 ## How it works
 
-- **One sequence per request.** Ollaya builds the prompt exactly as Cloudflare's `encode_record` does: the state, then every question with its options as a schema. The head reads the hidden states over each question's instructions and each option, routes evidence from the state to every option, and scores all options of all questions at once.
+- **One sequence per request.** The prompt is built exactly as Cloudflare's `encode_record` builds it: the state, then every question with its options as a schema. The head scores all options of all questions at once, from the hidden states over each question and option.
 - **Weights.** Cloudflare's four BF16 shards and the head's `joint_head.safetensors` download from Hugging Face, pinned to a commit and verified by sha256. Ollaya hosts only the ONNX graph (11 MB).
 - **Parity.** Ollaya's Rust runtime matches Cloudflare's own code in fp32 on CUDA: identical token ids and spans, and the same decision on all 571 test questions, probabilities within 6.3e-6.
-- **fp16 tag.** `clef:flash-fp16` computes the trunk in fp16 on NVIDIA GPUs, with the norms, the recurrent state, the attention softmax and the heads in fp32 ([how](https://github.com/ollaya-dev/ollaya/blob/main/docs/decisions/0008-fp16-decoder-tags.md)): {{result clef:flash-fp16 gpu.p50_ms 0}} ms for five questions on the RTX 5090 instead of {{result clef:flash gpu.p50_ms 0}} ms, {{result clef:flash-fp16 parity.cuda.decisions_same 0}} of {{result clef:flash-fp16 parity.cuda.questions 0}} decisions the same as `clef:flash` on the parity set, and {{result clef:flash-fp16 typed.accuracy 3}} on typed decisions. On a CPU use `clef:flash`.
+- **fp16 tag.** `clef:flash-fp16` runs the trunk in fp16 on NVIDIA GPUs ([how](https://github.com/ollaya-dev/ollaya/blob/main/docs/decisions/0008-fp16-decoder-tags.md)): {{result clef:flash-fp16 gpu.p50_ms 0}} ms for five questions on the RTX 5090 instead of {{result clef:flash gpu.p50_ms 0}} ms, {{result clef:flash-fp16 parity.cuda.decisions_same 0}} of {{result clef:flash-fp16 parity.cuda.questions 0}} decisions the same as `clef:flash` on the parity set, and {{result clef:flash-fp16 typed.accuracy 3}} on typed decisions. On a CPU use `clef:flash`.
 
 ## Limits
 

site/content/library/clm.md

@@ -20,8 +20,8 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `clm`
 
 ## Speed
 
-- **RTX 5090, through the HTTP API (Ollaya Bench):** the triage preset (five questions) on a new short message takes {{result clm:8b gpu.p50_ms 0}} ms at the median once the questions are cached, and under a millisecond for a repeated request. With nothing cached, five questions take about 0.5 s.
-- **Memory:** the encoder's weights stay BF16, about 16 GB; use a GPU with 20 GB or more. On a 24-core CPU a request takes about 13 s.
+- **RTX 5090, through the HTTP API (Ollaya Bench):** five questions on a new short message take {{result clm:8b gpu.p50_ms 0}} ms at the median once the questions are cached, under a millisecond for a repeated request and about 0.5 s with nothing cached.
+- **Memory:** the encoder's weights stay BF16, about 16 GB; use a GPU with 20 GB or more. On the Threadripper 3960X (24 cores) a request takes {{result clm:8b cpu.p50_ms 0}} ms.
 
 ## How it works
 

site/content/library/decider.md

@@ -28,7 +28,7 @@ ollaya run decider:4b --preset triage "My order never arrived and support ignore
 ollaya run decider:2b-vision --image shelf.png --questions '{"blocked":{"type":"noul","instructions":"Is the aisle blocked?"}}' "A photo from the warehouse camera."
 ```
 
-- **One PNG per request**, up to about one megapixel (1024x1024). The model's own preprocessing (Qwen's resize to multiples of 32 pixels, PIL's bicubic filter, normalization) is reproduced value for value, so a JPEG has to be converted to PNG first: Rust's JPEG decoders differ from the one the model's authors use by a few levels on some pixels.
+- **One PNG per request**, up to about one megapixel (1024x1024). The model's preprocessing is reproduced value for value, so convert a JPEG to PNG first: Rust's JPEG decoders differ from the authors' by a few levels on some pixels.
 - **Up to 10 options** per question (v5's lettered prompt, A to J). Text-only requests work too.
 - **Parity.** On 404 test questions, 12 of them with images: identical resized pixels, token ids and positions, the same decision on every question, and option logits within 1.6e-4 of the Python reference, on CPU and CUDA.
 - **Speed.** On an RTX 4090, five questions about a 256x240 image take about 200 ms, and about 0.9 s about a 1000x750 one. On the CPU, 3 to 16 seconds.
@@ -38,19 +38,19 @@ ollaya run decider:2b-vision --image shelf.png --questions '{"blocked":{"type":"
 
 ## Speed
 
-- **RTX 5090, through the HTTP API (Ollaya Bench):** a five-question request with a short state takes {{result decider:0.8b gpu.p50_ms 0}} ms on `0.8b`, {{result decider:2b gpu.p50_ms 0}} ms on `2b` and {{result decider:4b gpu.p50_ms 0}} ms on `4b` at the median. That is slower than the encoder models (`laya:en`: {{result laya:en gpu.p50_ms 0}} ms). `0.8b` and `2b` are still faster than hosted Jev (236–276 ms).
+- **RTX 5090, through the HTTP API (Ollaya Bench):** five questions with a short state take {{result decider:0.8b gpu.p50_ms 0}} ms on `0.8b`, {{result decider:2b gpu.p50_ms 0}} ms on `2b` and {{result decider:4b gpu.p50_ms 0}} ms on `4b` at the median: slower than the encoders (`laya:en`: {{result laya:en gpu.p50_ms 0}} ms), and for `0.8b` and `2b` still faster than hosted Jev (236–276 ms).
 - **State length:** cost grows with the number of options times the context length.
 - **Memory:** on a 24 GB GPU, `2b` handles states up to about 8k tokens. Longer states spill out of GPU memory and become very slow.
 
 ## How it works
 
 - **Weights.** They come from Mapika's own `model.safetensors`, downloaded from Hugging Face, pinned to a commit and verified by sha256. Ollaya hosts only the ONNX graph (8 to 11 MB).
-- **Precision.** Every model computes in fp32 on the BF16 weights. `0.8b` and `2b` widen the weights to fp32 when they load. `4b` keeps them BF16, half the memory, and widens each layer just before it runs; its answers are the same, and a forward pass takes about 12% longer.
+- **Precision.** fp32 compute on the BF16 weights. `0.8b` and `2b` widen the weights when they load; `4b` keeps them BF16 (half the memory) and widens each layer just before it runs, with the same answers and about 12% more time per pass.
 - **Calibration.** `4b` (v2.1) has one fitted temperature per answer type: choice 1.110, yes/no 1.560, score 1.287. `2b` and `0.8b` have one each.
 - **Parity.** Ollaya's Rust runtime matches the Python reference exactly: identical token ids and answer-slot positions, and the same decision on every test question, on CPU and CUDA.
 
 ## Limits
 
-- **Memory.** On the GPU, with requests of about 1,400 tokens, `2b` took about 13 GB and `4b` about 14 GB (`4b` keeps its 8.4 GB of weights BF16). All three are slow on the CPU, where `4b` peaked at 21 GB on the same requests; `4b` belongs on a GPU.
+- **Memory.** With requests of about 1,400 tokens, `2b` took about 13 GB of GPU memory and `4b` about 14 GB. All three are slow on the CPU, where `4b` peaked at 21 GB; `4b` belongs on a GPU.
 - **Score criteria.** Criteria given as an object instead of a list are rejected, as TypeSafe's API does.
 - **Instructions.** Every question needs `instructions`. Mapika's newer package also accepts a yes/no question without them; Ollaya rejects it.

site/content/library/decima.md

@@ -32,5 +32,5 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `deci
 ## Limits
 
 - **State.** 512 tokens per question (2,048 for `decima:agent`), the question included. `/v1/systemone` answers a longer state with `STATE_TRUNCATED`, as the author's server does; `/api/decide` answers from its first tokens.
-- **Options.** Each option row holds the question and the option in 64 tokens. When they don't fit, `decima:agent` keeps the option whole and shortens the question's copy beside it (the full question is still read with the state), as the author's 2.2 runtime does. `decima:base` and `decima:small` keep cutting the row on the right, which their training saw, except when that would make two options identical. 2 to 255 choices, 2 to 10 score levels.
+- **Options.** 2 to 255 choices, 2 to 10 score levels. Each option row fits the question and the option in 64 tokens: `decima:agent` shortens the question's copy and keeps the option whole, as the author's 2.2 runtime does; `base` and `small` cut the row on the right, as in training, unless two options would become identical.
 - **Languages.** Multilingual. The author evaluated small in 20 languages (the weakest are Swahili and Hindi). For base, the author reports Persian about 5 points below English on the same tasks, and other languages less tested.

site/content/library/decision.md

@@ -21,8 +21,8 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `deci
 ## Speed
 
 - **RTX 5090, through the HTTP API (Ollaya Bench):** a five-question request with a short message takes {{result decision:eos gpu.p50_ms 0}} ms at the median (`kev:0.8b` {{result kev:0.8b gpu.p50_ms 0}} ms, `decider:0.8b` {{result decider:0.8b gpu.p50_ms 0}} ms).
-- **CPU:** the same request takes about 0.85 s on a Mac mini (M4 Pro), through the daemon.
-- **State length:** every question reads the whole context again, so the cost grows with the number of questions times the context length. Five typed-decisions questions about a JSON state (about 1,050 tokens in all) take about 0.2 s on the RTX 4090, 0.84 s on the Mac mini and 2.1 s on a 24-core x86 CPU, measured in the runtime without HTTP.
+- **CPU:** the same request takes {{result decision:eos cpu.p50_ms 0}} ms on the Threadripper 3960X (24 cores).
+- **State length:** every question reads the whole context again, so the cost grows with the number of questions times the context length.
 
 ## How it works
 

site/content/library/jevk5.md

@@ -21,8 +21,8 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `jevk
 ## Speed
 
 - **RTX 5090, through the HTTP API (Ollaya Bench):** the triage preset (five questions) on a short customer message takes {{result jevk5:4b gpu.p50_ms 0}} ms at the median.
-- **RTX 4090, in the runner:** on the parity fixtures, whose states are longer, five questions take about 288 ms at the median. Every question is its own pass over the whole prompt (see below), so the time grows with the state times the number of questions.
-- **CPU:** not measured by Ollaya. The author reports about 0.6 s per short decision on a 32- or 48-thread CPU server.
+- **State length:** every question is its own pass over the whole prompt (see below), so the time grows with the state times the number of questions.
+- **CPU:** {{result jevk5:4b cpu.p50_ms 0}} ms for the same request on the Threadripper 3960X (24 cores). The author reports about 0.6 s per short decision on a 32- or 48-thread CPU server.
 
 ## How it works
 
@@ -31,7 +31,7 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `jevk
 - **Options.** Up to 16 per question, labelled `A` to `P`. A yes/no question reads `true` as `A` and `false` as `B`.
 - **Calibration.** Temperature 1.22 over the letters, the value the author gives for the v0.3 4B files.
 - **Engine.** llama.cpp v0.5.0, ggml-org's own release build, runs inside Ollaya's runner process. It uses an NVIDIA GPU (CUDA) or an Apple silicon GPU (Metal) when the model fits, and the CPU otherwise.
-- **Parity.** Ollaya's runner matches stock llama.cpp (`llama-server` of the same build, on the same file) on CUDA (RTX 4090): the same decision on all 593 test questions, probabilities within 1.6e-6. The prompts are byte-identical to the author's `jevk5.prompt` on all 450 fixture prompts. Not checked yet: the CPU, Metal and Windows.
+- **Parity.** On CUDA, Ollaya's runner matches stock `llama-server` of the same build on the same file: the same decision on all {{result jevk5:4b parity.cuda.questions 0}} test questions, probabilities within 1.6e-6, with prompts byte-identical to the author's `jevk5.prompt`. Not checked yet: the CPU, Metal and Windows.
 
 ## Limits
 

site/content/library/kev.md

@@ -29,10 +29,10 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `kev`
 
 - **One row per question.** The state comes first, then the question, then one span per option, then a decide token. The pointer head compares each option's closing token with the decide token.
 - **Calibrated.** The scores are divided by the temperature each checkpoint ships, fitted upstream on development data: 2.35 (`0.8b`), 2.41 (`4b`), 2.30 (`9b`).
-- **Weights.** The files download from Hugging Face, pinned to a commit and verified by sha256: the Qwen3.5 base weights from Qwen's repository, and the adapter and `head.pt` from Jared Palmer's. The adapter is applied at run time, not merged, so every file stays byte for byte the author's. Ollaya hosts only the ONNX graph (10 to 14 MB).
+- **Weights.** From Hugging Face, pinned to a commit and verified by sha256: the Qwen3.5 base from Qwen, the adapter and `head.pt` from Jared Palmer. The adapter is applied at run time, not merged; Ollaya hosts only the ONNX graph (10 to 14 MB).
 - **Precision.** The fp32 tags compute in fp32 on the BF16 base weights. `0.8b` widens them when it loads; `4b` and `9b` keep them BF16, half the memory, and widen each layer just before it runs.
 - **Parity.** Ollaya's Rust runtime matches upstream Kev exactly: identical token rows and option positions, and the same decision on every test question, on CPU and CUDA.
-- **fp16 tags.** `kev:4b-fp16` and `kev:9b-fp16` compute the trunk in fp16 on NVIDIA GPUs, with the norms, the recurrent state, the attention softmax and the heads in fp32 ([how](https://github.com/ollaya-dev/ollaya/blob/main/docs/decisions/0008-fp16-decoder-tags.md)). On the RTX 5090 five questions take {{result kev:4b-fp16 gpu.p50_ms 0}} and {{result kev:9b-fp16 gpu.p50_ms 0}} ms (fp32: {{result kev:4b gpu.p50_ms 0}} and {{result kev:9b gpu.p50_ms 0}} ms); on the parity set {{result kev:4b-fp16 parity.cuda.decisions_same 0}} and {{result kev:9b-fp16 parity.cuda.decisions_same 0}} of {{result kev:4b-fp16 parity.cuda.questions 0}} decisions are the same as the fp32 tag's, and on typed decisions they score {{result kev:4b-fp16 typed.accuracy 3}} and {{result kev:9b-fp16 typed.accuracy 3}}. `kev:0.8b` has no fp16 tag: its fp32 graph is as fast. On a CPU use the fp32 tags.
+- **fp16 tags.** `kev:4b-fp16` and `kev:9b-fp16` run the trunk in fp16 on NVIDIA GPUs ([how](https://github.com/ollaya-dev/ollaya/blob/main/docs/decisions/0008-fp16-decoder-tags.md)). On the RTX 5090: {{result kev:4b-fp16 gpu.p50_ms 0}} and {{result kev:9b-fp16 gpu.p50_ms 0}} ms for five questions (fp32: {{result kev:4b gpu.p50_ms 0}} and {{result kev:9b gpu.p50_ms 0}} ms), {{result kev:4b-fp16 parity.cuda.decisions_same 0}} and {{result kev:9b-fp16 parity.cuda.decisions_same 0}} of {{result kev:4b-fp16 parity.cuda.questions 0}} parity decisions the same as fp32, {{result kev:4b-fp16 typed.accuracy 3}} and {{result kev:9b-fp16 typed.accuracy 3}} on typed decisions. `kev:0.8b` has no fp16 tag (its fp32 graph is as fast). On a CPU use the fp32 tags.
 
 ## Limits
 

site/content/library/nimble.md

@@ -27,12 +27,12 @@ Point any TypeSafe client at `http://localhost:11435` and set the model to `nimb
 
 ## How it works
 
-- **Prompt.** Ollaya builds Nimble's prompt exactly as the author's code does (`serving_schema.prepare_prompts` in the model repository), and maps TypeSafe questions to Nimble's schema the way the author's own `/v1/systemone` server does: noul becomes a true/false field, choice an enum of its labels, score an enum of its levels.
+- **Prompt.** Built exactly as the author's `serving_schema.prepare_prompts` builds it, with TypeSafe questions mapped as the author's `/v1/systemone` server maps them: noul to a true/false field, choice to an enum of its labels, score to an enum of its levels.
 - **Calibrated.** Probabilities use the author's recommended temperature, 2.179 (`temperature_config.json`). A plain softmax of the code logits, what Ollama returns, is overconfident.
 - **Up to 255 options.** Questions with more than 26 options use the author's serving extension: two-letter codes and the "short code" prompt.
-- **Weights.** Qwen's Qwen3.5-9B shards and Bespoke Labs' adapter download from Hugging Face, pinned to a commit and verified by sha256. The adapter is applied at run time, not merged, so every file stays byte for byte the authors'. Ollaya hosts only the ONNX graph (14 MB).
+- **Weights.** Qwen3.5-9B from Qwen and Bespoke Labs' adapter, from Hugging Face, pinned to a commit and verified by sha256. The adapter is applied at run time, not merged; Ollaya hosts only the ONNX graph (14 MB).
 - **Parity.** Ollaya's Rust runtime matches the author's code in fp32 on CUDA: identical token rows, the same rejections and the same decision on all 492 test questions, probabilities within 6.5e-6. `nimble:9b-v3` matches the author's Decision Index engine the same way on 498 questions, probabilities within 1.1e-5.
-- **fp16 tag.** `nimble:9b-fp16` computes the trunk in fp16 on NVIDIA GPUs, with the norms, the recurrent state, the attention softmax and the heads in fp32 ([how](https://github.com/ollaya-dev/ollaya/blob/main/docs/decisions/0008-fp16-decoder-tags.md)): {{result nimble:9b-fp16 gpu.p50_ms 0}} ms for five questions on the RTX 5090 instead of {{result nimble:9b gpu.p50_ms 0}} ms, {{result nimble:9b-fp16 parity.cuda.decisions_same 0}} of {{result nimble:9b-fp16 parity.cuda.questions 0}} decisions the same as `nimble:9b` on the parity set, and {{result nimble:9b-fp16 typed.accuracy 3}} on typed decisions. On a CPU use `nimble:9b`.
+- **fp16 tag.** `nimble:9b-fp16` runs the trunk in fp16 on NVIDIA GPUs ([how](https://github.com/ollaya-dev/ollaya/blob/main/docs/decisions/0008-fp16-decoder-tags.md)): {{result nimble:9b-fp16 gpu.p50_ms 0}} ms for five questions on the RTX 5090 instead of {{result nimble:9b gpu.p50_ms 0}} ms, {{result nimble:9b-fp16 parity.cuda.decisions_same 0}} of {{result nimble:9b-fp16 parity.cuda.questions 0}} decisions the same as `nimble:9b` on the parity set, and {{result nimble:9b-fp16 typed.accuracy 3}} on typed decisions. On a CPU use `nimble:9b`.
 
 ## Limits