Laya 300 — eval-host replication & comparison

2026-09-28 · eval host (Ryzen 7 7800X3D) vs control host (Ryzen 9 6900HX) · identical 300-state eval · identical question set v1.1 · identical checkpoints · all numbers measured from the live runs

The premise

The Laya 300 gate (see the status & power report) was run on the control host: a Ryzen 9 6900HX mini-PC serving three Laya checkpoints on CPU, loopback-only. The question this run answers: does the same decision engine produce the same decisions on different hardware, and what does it cost there? The same 300 alert states (pulled from the live ingest stream), the same question set v1.1, the same typed-decisions checkpoint, the same sequential-POST methodology — on a second host with nothing in common with the first except the model files.

1.60×

mean latency speedup on the eval host

100.0%

cross-host answer agreement (300/300 states)

−20%

package energy per decision

failed decisions across both hosts

The hosts

	Eval host (new)	Control host (gate reference)
Role	evaluation / candidate decision node	SOC control plane + decision serving
CPU	AMD Ryzen 7 7800X3D — 8C/16T, 5.05 GHz boost, 3D V-Cache	AMD Ryzen 9 6900HX — 8C/16T, 4.94 GHz boost
RAM	124 GB	109 GB usable
GPU	NVIDIA RTX 5060 Ti 16 GB (idle for this run: 4.7 W, 43 °C)	none (iGPU only)
OS	Ubuntu 24.04.5 LTS	Ubuntu 24.04
laya-serve	0.3.20, CPU, 8 threads, 3 checkpoints preloaded, loopback-only	identical configuration

The 300-decision run

Same methodology as the control-host gate: 300 alert states built by the same build_alert_state() contract from the live ingest stream (the most recent 300 alerts, chronological), one typed-decisions predict per state, sequential POSTs to each host's loopback laya-serve. Severity ground truth is the objective rule-level contract (0–2 informational, 3–7 low, 8–11 medium, 12–13 high, 14+ critical) — no LLM judge.

520.4 ms

eval host — latency p50

536.5 ms

eval host — latency p95

780.6 ms

control host — latency p50

1010.5 ms

control host — latency p95

metric	eval host (7800X3D)	control host (6900HX)	delta
latency p50	520.4 ms	780.6 ms	1.50× faster
latency p95	536.5 ms	1010.5 ms	1.88× faster
latency mean	518.5 ms	830.8 ms	1.60× faster
ok / fail	300 / 0	300 / 0	both clean
input tokens (300 states)	127,869	127,869	identical
severity agreement vs contract	8.7%	8.7%	identical behavior
response classes	email 262 · note_only 36 · page 2 — identical on both hosts

Agreement — the decisions are host-independent

The same 300 states answered by both hosts produced identical decisions: severity choice 300/300, response choice 300/300, and the known-pattern noul scores within ±0.05 on every state. The decision engine is deterministic per state — moving it between hosts does not change what the SOC decides, only how fast it decides.

Power

Package energy (RAPL, powercap) sampled around each host's 300-decision run, with a 15-second idle baseline (checkpoints preloaded, service idle) taken immediately before:

	eval host (7800X3D)	control host (6900HX)
idle package power	21.52 W	8.41 W
eval average package power	68.94 W	53.63 W
package energy, 300 decisions	10,727 J (2.98 Wh)	13,370 J (3.71 Wh)
energy per decision	35.8 J (0.0099 Wh)	44.6 J (0.0124 Wh)
wall time for 300	155.6 s (1.93 decisions/s)	249.3 s (1.20 decisions/s)

Two honest readings. Per decision, the eval host is cheaper: 35.8 J vs 44.6 J (−20%) because it finishes faster. Idle, it is more expensive to leave switched on: the 7800X3D's chiplet design idles at 21.5 W package where the 6900HX idles at 8.4 W — a 13 W gap that matters only if the node runs 24/7 between decision bursts (13 W × 24 h = 0.31 kWh/day). Neither host's laya-serve GPU was engaged: the RTX 5060 Ti sat at 4.7 W, 43 °C throughout.

Agreement vs the deterministic contract — 8.7% on this slice

The eval slice matters: these 300 states are the most recent live-stream tail — dominated by a level 8–11 web-400 flood family (285 of 300 expected medium, 15 expected high). On this flood-heavy mix the typed-decisions checkpoint inflates severity: it answers high for 259 of the 285 contract-medium states (and “medium” for 13 of the 15 contract-high states) — the same 8.7% agreement on both hosts, so this is the model's view of this alert family, not a host difference. This is exactly the behavior the Phase 4 fine-tune targets; until then the deterministic severity rule remains authoritative and laya confirms. The response recommendations follow the severity: email 262 / note_only 36 / page 2 — which is also why the live per-alert email flood fix (digest folding) matters.

Thermal & HVAC

All electrical power becomes heat; the HVAC system removes it. Measured at the package:

Control host: 53.6 W average during its 300-decision run (249 s) = 183 BTU/hr sustained; 8.4 W idle = 29 BTU/hr.
Eval host: 68.9 W average during its run (156 s) = 235 BTU/hr sustained; 21.5 W idle = 73 BTU/hr. CPU temperature 55.9–58 °C under load (well under the 89 °C Tjmax).
The daily SOC decision load (480 decisions/day at the live rate) draws ~4.8 Wh/day of decision compute on either host = 16.4 BTU/day — a rounding error in any HVAC budget.
The GPU host context: the llama.cpp fleet it replaces drew 4.92 kWh/day of GPU energy always-on = 16,780 BTU/day of waste heat. The laya migration cut the decision-path GPU energy −74% (4.92 → 1.29 kWh/day) — the same reduction lands directly on the room's cooling duty. The eval host's RTX 5060 Ti (16 GB, idle 4.7 W) sits available as reserve GPU capacity and adds essentially nothing while idle.

Reproduce

Per host (Ubuntu 24.04, any modern x86 CPU — no GPU required for the CPU path):

python3 -m venv ~/laya/.venv
~/laya/.venv/bin/python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
~/laya/.venv/bin/python -m pip install "laya[serve]"
HF_HOME=~/laya/hf-cache ~/laya/.venv/bin/python -c "from laya import Router; Router(preload=True)"

Then a systemd user unit running laya-serve with LAYA_HOST=127.0.0.1 LAYA_PORT=8099 LAYA_DEVICE=cpu LAYA_PRELOAD=1 LAYA_THREADS=8 LAYA_MODELS=english,multilingual,typed-decisions (loopback-only; never expose it without its API key). Driver + results: evals/laya-300-run.py, evals/results-laya300-*-summary.json in laya-control.

Same model, same answers, different silicon. The decision engine is host-independent: identical answers across an 8-core desktop X3D and a 6900HX mobile-class part, 1.6× faster on the newer host, at roughly a third of the GPU decision path's energy. For capability statements or a live walkthrough: info@bedimsecurity.com.

Methodology: identical 300-state eval (last 300 alerts from the live ingest stream, anonymized), qset v1.1, model=typed-decisions, sequential POSTs, RAPL package-energy sampling per run wall, k10temp/hwmon temperatures, nvidia-smi GPU sampling. Alert-sample IPs/domains anonymized to RFC 5737; internal host names replaced by role labels. Companion: Laya 300 — status & power report.