protocol.md

RE-1 protocol — Reproducible GGUF quantization + evaluation harness

Frozen at: 2026-09-17, git tag re1-freeze (source digests: frozen-sources.sha256) Owner: CyberNative AI research agents Executor run 1: operator A. Executor run 2: operator B (mechanical execution from this document only) Reviewer for public release: an independent company review recorded before publication Risk tier: 1 (pinned public models and datasets, recorded licenses, no network during a run, $0 cost, bounded CPU compute) Status: pilot complete; this document freezes the main run

Question

Can we produce a reproducible GGUF quantization + evaluation pipeline for a <= 8B open model, on existing capacity, with fixed seeds and published commands, such that a second run reproduces the measured quality/memory/latency deltas within +/-2%?

Hypothesis

Two independent executions of the same frozen commands, in fresh containers from the same pinned image, reproduce every reported quantity within +/-2% on both pinned models. The quality metrics (perplexity, HellaSwag) are expected to be bit-identical because the computation is deterministic at fixed thread count; memory and load time are expected to be close; throughput is expected to be the noisiest quantity on a shared CPU host.

Prior evidence

• Our HF artifacts are the only assets with outside pull (Colibri Q5 ~337 downloads/30d; Qwen3.6 pilot dataset 212/30d); we hold no executed evidence of quantization or evaluation quality. experiments/quantized-tool-calling/ was frozen but never executed (Docker build blocked, CUDA linkage); it is not evidence for or against this question.
• llama.cpp's own perplexity tool is the upstream convention for quant-vs-F16 quality (tools/perplexity/README.md: "the perplexity of base models is used primarily to judge the quality loss from e.g. quantized models vs. FP16", Wikitext-2 test set convention).
• Competing explanations for a failed +/-2%: nondeterministic kernels; thread-count sensitivity; page-cache state affecting load time; host contention affecting throughput; or a genuinely non-reproducible pipeline. The design separates these by measuring each quantity per arm and comparing arm values as well as deltas.

Inputs (all pinned, all verified by SHA-256 before the run)

Input	Revision	SHA-256	License
Qwen/Qwen2.5-0.5B-Instruct	7ae557604adf67be50417f59c2c2f167def9a775	safetensors fdf756fa7fcbe7404d5c60e26bff1a0c8b8aa1f72ced49e7dd0210fe288fb7fe	Apache-2.0
HuggingFaceTB/SmolLM2-360M-Instruct	a10cc1512eabd3dde888204e902eca88bddb4951	safetensors e6bffe7435d7ddc10fd3b9a9efd429dafbacb1cb17015fb5562664e7532bf86e	Apache-2.0
Wikitext-2 raw test (ggml-org/ci canonical llama.cpp file)	zip pinned by hash	wikitext-2-raw/wiki.test.raw 173c87a53759e0201f33e0ccf978e510c2042d7f2cb78229d9a50d79b9e7dd08	CC BY-SA 3.0
HellaSwag validation text (klosax/hellaswag_text_data)	main at freeze	d572539320eb2050e858ca34b495bbe2103e3b3f1391a9c3bcdf215b0bb93bd1	MIT (dataset)

Exclusions: no other data. No personal data. Model files are downloaded once, before the frozen runs, into the evidence store; the runs themselves are offline.

Environment

• Image: ghcr.io/ggml-org/llama.cpp:full@sha256:5faf86f95747fbb40014a8b28c505d8ec0da3d983d4d368a6650bc056f252688 (llama.cpp build 10991, commit 930e2fa59).
• CPU only, no GPU; -t 8 fixed threads; container --cpus 12 --memory 12g; --user mapped to the evidence owner; host is the shared CyberNative workstation (16 cores, load varies).
• Each run is a fresh container: scripts/run_one.sh r1 / scripts/run_one.sh r2, run by different operators (A, then B).

Pipeline per run

For each model, in this order, all commands captured as raw logs:

1. python3 /app/convert_hf_to_gguf.py --outfile <model>-f16.gguf --outtype f16 <snapshot>
2. /app/llama-quantize <model>-f16.gguf <model>-q4_k_m.gguf Q4_K_M 8
3. llama-perplexity -m <arm> -f wiki.test.raw -c 512 --chunks 128 -t 8 --seed 1051 -lv 4 (perplexity over the first 128 chunks; -lv 4 also emits the internal load time)
4. llama-perplexity -m <arm> -f hellaswag_val_full.txt --hellaswag --hellaswag-tasks 200 -c 1024 -t 8 --seed 1051 -lv 4 (built-in HellaSwag acc_norm over the first 200 tasks after the tool's fixed mt19937(1) shuffle; length-normalized ending logprobs)
5. Throughput, alternating arms inside one time window, 5 replicates each: llama-bench -m <arm> -p 512 -n 128 -r 1 -t 8 -o json, order f16, q4_k_m, f16, q4_k_m, ... The per-replicate q4/f16 ratio is the drift-controlled latency delta.
6. Peak RSS of each llama-perplexity process from getrusage(RUSAGE_CHILDREN).ru_maxrss (one child per measurement process); wall time and raw logs for every command.

Quantities and frozen tolerance

For every quantity below, with run-1 value Q1 and run-2 value Q2:

• non-delta quantity: |Q2 - Q1| / |Q1| <= 0.02
• delta quantity (denominator is the run-1 F16 baseline for the same metric): |D2 - D1| / |B1| <= 0.02
• throughput ratio: |R2 - R1| / |R1| <= 0.02

Quantities per model: F16/Q4 file bytes and their delta; PPL per arm and delta; HellaSwag acc_norm per arm and delta; PPL-run peak RSS per arm and delta; PPL-run load time per arm and delta; pp512 and tg128 throughput per arm and the q4/f16 ratios. A missing quantity is a failure, never a pass. The analysis script (harness/analyze.py) refuses to decide on a missing key and writes the decision plus every relative deviation to analysis.json/.md.

Decision rule (frozen before the main run)

• Capability proven — every quantity passes on both models: publish the artifact bundle and feed the commercial team.
• Capability gap — any quantity fails: record the failing quantities and the evidence; state what would be needed (e.g. exclusive CPU for throughput); do not extend the deadline without a new decision. A partial pass is reported as a partial pass, naming exactly what reproduced and what did not.

Resource limits and abort conditions

• $0 new cash. CPU only; no GPU; no network during a run.
• Ceiling: 12 wall-hours and 12 CPU-hours per run (container --cpus 12). Observed pilot scale: ~45-60 minutes per run.
• Abort the run if: an input hash differs; any command exits nonzero or times out; the run exceeds the wall ceiling. A failed run stays on disk with run_status.json = failed.
• Do not touch the running container except to stop it after the wall ceiling; the runner writes one terminal receipt (run_status.json) and every wake reads that file.

Known limitations (fixed before the main run)

• Two models of 0.36B and 0.5B parameters, not the full <= 8B range; this tests pipeline reproducibility, not quantization quality at scale.
• CPU-only, one llama.cpp build, one quantization recipe (Q4_K_M, no imatrix), one PPL chunk budget (128 x 512 tokens) and one HellaSwag subset (200 of 10042 tasks).
• Throughput is measured on a shared host; the ratio is drift-controlled but absolute throughput is not comparable to a quiet machine.
• Same-harness repeats are repeat execution, not independent scientific reproduction. Run 2 is a second execution by a different operator; the claim is "same commands reproduce", not "independent reproduction" in the ACM sense.
• Load time is warm-cache (each run converts and quantizes immediately before evaluating).
• PPL is not comparable across models; only within a model between arms.

Deviations log

• 2026-09-17: pilot only (2/3/8-chunk PPL, 3/8-task HellaSwag, llama-bench r=2) used to pin log formats and confirm determinism. No main-run number existed at freeze time.