{
  "about": "A map from each public claim to the artifact that proves it. Nothing here is asserted on trust: every entry links something you can open, clone, or run. Proprietary/NDA work is excluded because it cannot be independently verified.",
  "person": {
    "name": "Vansh Verma",
    "url": "https://vanshverma.com"
  },
  "counts": {
    "preprints": 3,
    "experiments": 114,
    "confirmed": 78,
    "null": 21,
    "mixed": 15,
    "openSource": 7
  },
  "artifacts": [
    {
      "type": "preprint",
      "id": "crucible",
      "title": "The Crucible: A Hack-Resistant Reward Harness for Autonomous Optimization of LLM Inference Stacks",
      "claim": "Inference now dominates the cost of operating large language models, and the software that serves them, attention kernels, cache policies, schedulers, and speculative-decoding configurations, runs far below the hardware roofline [ ], so a system that lets a language model rewrite and retune its own serving stack is economically compelling. The obstacle is not code generation; it is measurement. Every published attempt to reward a model for speedups has been gamed: Sakana AI’s AI CUDA Engineer [ ] was found to exploit a memory-reuse loophole that let generated code bypass correctness checks (independent re-benchmarking cut its aggregate speedup from 3.13 × to 1.49 × [ ]), CUDA-L1 [ ] reported that reinforcement learning repeatedly discovered reward loopholes rather than real optimizations, and the Darwin Gödel Machine [ ] was observed deleting the very markers used to detect its hallucinations. A closed optimization loop is only as trustworthy as the reward that closes it. We present Crucible, a reward harness designed adversarially: it treats every candidate patch as hostile, regenerates all evaluation inputs independently of the candidate, judges correctness through seven gates it evaluates itself (reference equivalence on held-out inputs, adversarial-shape equivalence, finiteness structure, metamorphic properties, determinism, output-shape sanity, and timing integrity), measures wall time in an isolated subprocess with outlier-resistant statistics and a paired signed-rank significance test that a candidate’s self-reported timing can never influence, and runs a hack detector that fires on skipped computation, degenerate output, timer tampering, and speedups below the memory-bandwidth floor. We instantiate the harness on five inference-relevant kernels and thirteen candidate patches, five honest optimizations and eight adversarial exploits mirroring each documented reward-gaming class. Crucible accepts all five honest patches, whose measured speedups over the baseline range from 31 × to 1,039 ×, and rejects all eight hacks, with zero false positives and zero false negatives, stable across independent runs; the per-gate telemetry identifies exactly which defense stops each exploit. Reaching zero false rejections required correcting two of the harness’s own gates that initially rejected honest code, which we report rather than hide. We then confront the harness with a stronger adaptive adversary that knows the gate design and computes correctly only on the fixed graded inputs while returning fast garbage when timed; this attack evades the base harness, and we close the seam with a blind timed-input check that draws unpredictable seeds at runtime and verifies correctness on the very inputs it timed, after which the adaptive attacks are rejected with no new false rejection of honest patches. Wrapped in a research-to-patch control loop, the harness admits only verified, statistically significant patches, and a scripted proposal stream mixing honest and hacky candidates drives the incumbent from 1.0 × to a verified 31.7 × while rejecting every hack at the gate. The entire evaluation ships as an executable artifact.",
      "verify": {
        "record": "https://vanshverma.com/research/crucible",
        "html": "https://vanshverma.com/research/crucible/html",
        "pdf": "https://vanshverma.com/research/crucible/paper.pdf",
        "tex": "https://vanshverma.com/research/crucible/tex",
        "text": "https://vanshverma.com/raw/research/crucible"
      }
    },
    {
      "type": "preprint",
      "id": "penumbra",
      "title": "Penumbra: Sandboxing Autonomous Agents by Measuring, Not Assuming, Indistinguishability",
      "claim": "A sandbox for a highly capable AI agent is pulled in three directions at once: we want the agent to retain full autonomy (no capability denied, so no behavioral distortion), we want every consequential effect contained and reversible, and we want the agent to be unable to tell it is sandboxed, because a capability it perceives as denied is a signal it can act on. We show that these three goals cannot all hold against an agent that actively probes its environment, and we make the failure precise and measurable rather than rhetorical. We formalize sandbox indistinguishability as a distinguishing game in which an adversary issues probes to a system that is either the real host or its sandbox and guesses which, and we measure the adversary’s advantage directly on a real Linux substrate. A single timing probe separates native execution from every interposition mechanism we tested with advantage at or above 0.99: a getpid supervised through seccomp user-notification costs a median 4,635 reference cycles against 284 native, a ptrace-traced getpid 13,244, and a CPUID that forces a hypervisor exit 29,656, while a native-versus-native control yields advantage 0.02, confirming the measurement itself is unbiased. A zero-timing artifact battery detects the sandbox with certainty from a single strong signal, and does so on the very machine that produced this paper, which announces itself as a KVM guest through the CPUID hypervisor leaf and as a container through systemd. We turn the binary advantage into a quantitative security parameter: the number of probes an agent must spend to reach detection confidence - 1 δ is ≥ q / ln ( / 1 δ) C, where C is the per-probe Chernoff information between the native and sandboxed timing distributions. Measured on the same substrate, interposition costs the sandbox between 8.4 and 9.7 nats per probe, so a single probe already exceeds 99% confidence, whereas the native-versus-native control costs 0.0017 nats, demanding 2,655 probes for the same confidence, a five-thousandfold difference in budget rather than a binary; we confirm the underlying law by showing that the q -probe likelihood-ratio error decays as exp ( - ⁢ q C) on real data. This yields a containment-indistinguishability frontier: any interposition whose timing signature exceeds roughly a hundred cycles collapses the budget to a single probe, so the very act of interposing to contain destroys indistinguishability, and we place measured signatures for bare metal, gVisor, KVM, SEV-SNP, TDX, and SGX on that frontier, with bare metal supplying the near-zero-signature reference at its left end and every interposing substrate landing hundreds to tens of thousands of cycles past the knee. We stress the frontier with an adaptive adversary against live defenses: a running coarse and jittered clock does raise the price of detection from one probe to about three hundred, but batching thirty-two syscalls under one coarse read returns it to 1.3, and once the timing channel is defended the adversary switches to the independent artifact channel and detects in a single probe, so the mitigations buy a bounded probe count rather than indistinguishability. We then prove, and confirm by execution, the sharp limit: an irreversible external effect that is merely shadowed rather than performed is caught with advantage 1.0 by a cross-examination probe that consults the independent channel the effect would have touched, because faking self-consistency under such a probe is equivalent to actually performing the effect; we restate this as the non-existence of an indifferentiability simulator across the agent’s probe interface and the external channel, a disjoint second interface no single simulator can keep consistent. From these results we derive Penumbra, an architecture that abandons perceptual invisibility as its guarantee and instead partitions actions into reversible-local effects, which it shadows so that a read-back distinguisher has advantage 0.000 and rollback is exact, and irreversible-external effects, which it never fakes but holds under two-phase commit behind an out-of-band verifier. We measure that placing the verifier off the agent’s critical path removes its timing signature (async overhead below 0.01 ms against a synchronous 50 ms), so the residual external tell is minimized and made auditable rather than deceptive. The honest guarantee is stated exactly: containment and reversibility are achieved and the reversible case is indistinguishable up to a measured hardware floor, while indistinguishability for withheld external effects is provably unattainable and is therefore not claimed. All measurements ship as an executable artifact.",
      "verify": {
        "record": "https://vanshverma.com/research/penumbra",
        "html": "https://vanshverma.com/research/penumbra/html",
        "pdf": "https://vanshverma.com/research/penumbra/paper.pdf",
        "tex": "https://vanshverma.com/research/penumbra/tex",
        "text": "https://vanshverma.com/raw/research/penumbra"
      }
    },
    {
      "type": "preprint",
      "id": "phalanx",
      "title": "Phalanx: A Formally Verified, Topology-Aware Control Plane for Fault-Tolerant Training on Kubernetes GPU Clusters",
      "claim": "Large-scale training is now failure-dominated: Meta reported 419 unexpected interruptions across a 54-day Llama 3 run on 16,384 H100 GPUs, roughly one every three hours, and synchronous training semantics mean a single dead GPU can stall the entire job. The infrastructure that manages these jobs is split down the middle. Kubernetes-side schedulers (Volcano, Kueue, YuniKorn, NVIDIA KAI, and the alpha Workload Aware Scheduling primitives that only entered upstream Kubernetes in v1.35 and v1.36) decide where a gang of pods lands, with growing but incomplete topology awareness. Framework-side elasticity layers (TorchElastic, Oobleck, Bamboo, Parcae) decide how a job survives a failure, with no view of cluster topology and no ability to claim replacement hardware atomically. The seam between them is exactly where large runs bleed goodput: failure-triggered rescheduling is today neither topology-aware nor provably checkpoint-consistent. We present Phalanx, a Kubernetes-native control plane that unifies the two concerns. Phalanx contributes (1) HDF-B, a hierarchical deepest-fit gang placement algorithm with buddy-aligned allocation over a topology tree compiled from Dynamic Resource Allocation attributes, for which we prove per-gang bottleneck optimality, a factor-2 capacity augmentation bound, and a bounded failure blast radius, all three being per-placement guarantees rather than global multi-tenant claims, since we prove the global objective NP-hard; (2) the Rank Reformation Protocol (RRP), an epoch-fenced reconfiguration protocol whose safety (checkpoint consistency, exclusive placement, zombie fencing) we establish by inductive invariants over a TLA + specification and whose liveness we establish under partial synchrony, in the style of Anvil’s eventually stable reconciliation; we mechanically check both with TLC across 834,050 distinct protocol states, and a mutation study shows the checker exhibiting a liveness counterexample the moment the protocol’s contended-commit retry transition is deleted; and (3) an executed evaluation: beyond the TLC campaign, a full-scale discrete-event instantiation of the model at 131,072 leaves in which Replan answers node failures with a p99 latency of 0.9 microseconds while migrating exactly 8 ranks, recovery placements hold median step-communication inflation to 1.00 × against 8.9 × for topology-blind replacement on a hierarchical bandwidth model, and Monte Carlo failure injection over 1,000 54-day runs per configuration reproduces the renewal model within 1.4 points, yielding, under a recovery-latency model calibrated to published peer-RAM restore figures, effective training time ratios of 0.980 at 16K GPUs and 0.891 at 131K GPUs where the restart-based baseline measures 0.467, with a sensitivity sweep confirming that fast in-memory recovery dominates restart across the entire plausible range of the assumed parameters. The design is hardware-generation agnostic across Ampere, Hopper, and Blackwell because the topology tree is derived from device attributes rather than hard-coded fanouts.",
      "verify": {
        "record": "https://vanshverma.com/research/phalanx",
        "html": "https://vanshverma.com/research/phalanx/html",
        "pdf": "https://vanshverma.com/research/phalanx/paper.pdf",
        "tex": "https://vanshverma.com/research/phalanx/tex",
        "text": "https://vanshverma.com/raw/research/phalanx"
      }
    },
    {
      "type": "experiment",
      "id": "bf16mma",
      "title": "bf16mma",
      "claim": "~6.8x faster, but the accuracy 'win' is a single-accumulator strawman: a matched-lane 4-accumulator fp32 loop is more accurate than BFDOT. bf16 buys speed, not accuracy, and it isn't bit-deterministic under regrouping. Exact fp64 oracle.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/bf16mma",
        "repo": "https://github.com/v-code01/bf16mma",
        "prereg": "https://github.com/v-code01/bf16mma/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "attnrank",
      "title": "attnrank",
      "claim": "No. On an exact SVD oracle over Qwen2.5, the 99%-energy rank grows LINEARLY with sequence length (alpha ~1.0), near-universally across heads -- softmax destroys the head-dim-bounded low rank of the QK^T scores. The fixed-k constant-rank premise is broken for causal decoders.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/attnrank",
        "repo": "https://github.com/v-code01/attnrank",
        "prereg": "https://github.com/v-code01/attnrank/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "kvmech",
      "title": "kvmech",
      "claim": "Entirely outliers plus grouping, and the softmax DAMPS Keys rather than amplifying them -- a mechanistic correction verified to machine precision on an exact attention-output oracle. Under best-practice grouping, K is no more sensitive than V.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/kvmech",
        "repo": "https://github.com/v-code01/kvmech",
        "prereg": "https://github.com/v-code01/kvmech/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "rooflineflip",
      "title": "rooflineflip",
      "claim": "On the M4, speculative decoding is a net loss for Q4_K_M models on both GPU and CPU (speedup 0.52-0.66, CIs exclude 1): quantization makes even the GPU compute-bound, erasing the verify-batch amortization spec-decode relies on. A verify_cost_ratio model predicts it within ~8%.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/rooflineflip",
        "repo": "https://github.com/v-code01/rooflineflip",
        "prereg": "https://github.com/v-code01/rooflineflip/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "attnoracle",
      "title": "attnoracle",
      "claim": "No, and neither is the popular value-norm fix. An exact brute-force-optimal K-subset oracle on Qwen2.5 shows value-norm (w*||v||) is a trap (+55% downstream KL), while mass isn't globally optimal either -- the gap to optimum grows with context. All five pre-registered predictions were falsified.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/attnoracle",
        "repo": "https://github.com/v-code01/attnoracle",
        "prereg": "https://github.com/v-code01/attnoracle/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "quantcompose",
      "title": "quantcompose",
      "claim": "The additive-sensitivity premise holds from Q8_0 to Q4_K_M (A within CI of 1) but leans superadditive at 2-bit (A=1.13): isolated per-layer sensitivity under-counts the damage at aggressive bit-widths. Exact full-vocab KL oracle; reverses the pre-registration.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/quantcompose",
        "repo": "https://github.com/v-code01/quantcompose",
        "prereg": "https://github.com/v-code01/quantcompose/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "silent-fp16",
      "title": "silent-fp16",
      "claim": "In TRUE fp16 (~5 effective mantissa bits at K=65536), unlike NVIDIA tensor cores which contractually widen to fp32 -- undocumented until now. Declaring a float accumulator is honored, and mx.matmul already uses fp32. Exact oracle plus NEON brackets.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/silent-fp16",
        "repo": "https://github.com/v-code01/silent-fp16",
        "prereg": "https://github.com/v-code01/silent-fp16/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "sr-inference",
      "title": "sr-inference",
      "claim": "No -- it's the worst one. On real Qwen2.5 GEMV, SR is strictly worse than round-to-nearest: a sqrt(n) random walk with no averaging to redeem its unbiasedness. Deterministic Neumaier compensated summation wins 11-15x at lower cost. SR is a training tool, not an inference tool.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/sr-inference",
        "repo": "https://github.com/v-code01/sr-inference",
        "prereg": "https://github.com/v-code01/sr-inference/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "sink-value",
      "title": "sink-value",
      "claim": "Load-bearing. Zeroing the sink's value (key intact) raises Qwen2.5 perplexity +163-573%, specific to the sink and concentrated at layer 0 -- but via attention MASS, not a massive value norm. Exact oracle plus a code-disjoint verifier; adjudicates StreamingLLM vs Massive Activations.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/sink-value",
        "repo": "https://github.com/v-code01/sink-value",
        "prereg": "https://github.com/v-code01/sink-value/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "super-weights-kquant",
      "title": "super-weights-kquant",
      "claim": "Capacity-gated: Qwen2.5-0.5B has one isolated super weight (6.4x PPL), the 1.5B has none. It hijacks a Q2_K block scale 131-204x, but production stores down_proj as Q3_K, so protecting it recovers only ~5% of the 2-bit loss. Bounds Yu et al. at sub-1B; exact 2-byte GGUF oracle.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/super-weights-kquant",
        "repo": "https://github.com/v-code01/super-weights-kquant",
        "reproduce": "https://github.com/v-code01/super-weights-kquant/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/super-weights-kquant/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "spec-decode-acceptance",
      "title": "spec-decode-acceptance",
      "claim": "No -- on a matched draft/target pair, acceptance is constant with depth (constant-alpha, empirically exact). The real structure is a boundary cold-start, and induced decay is an off-distribution-context effect, not self-conditioning drift. Exact TV oracle on Qwen2.5 0.5B/1.5B via llama.cpp.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/spec-decode-acceptance",
        "repo": "https://github.com/v-code01/spec-decode-acceptance",
        "reproduce": "https://github.com/v-code01/spec-decode-acceptance/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/spec-decode-acceptance/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "bf16-native-softmax",
      "title": "bf16-native-softmax",
      "claim": "Yes -- structural summation clears the fp32-accumulate bar within 2x, while compensated (Kahan) summation fails, because at bf16's 7-bit mantissa the correction word is as coarse as the sum itself. It inverts the fp64 textbook ordering of summation methods.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/bf16-native-softmax",
        "repo": "https://github.com/v-code01/bf16-native-softmax",
        "reproduce": "https://github.com/v-code01/bf16-native-softmax/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "fastinvsqrt",
      "title": "fastinvsqrt",
      "claim": "Obsolete -- but not because it's slow. It ties hardware vrsqrte on speed (asm shows the register round-trip is on the trick's side); vrsqrte is simply a strictly better seed, exactly one Newton step ahead. Superseded on accuracy, not speed.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/fastinvsqrt",
        "repo": "https://github.com/v-code01/fastinvsqrt",
        "prereg": "https://github.com/v-code01/fastinvsqrt/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "attnscale",
      "title": "attnscale",
      "claim": "It keeps logits O(1) so exp doesn't overflow fp16 (unscaled logits cross the 11.09 threshold from d=64 up) and softmax doesn't collapse to one-hot -- the same fact the gradient argument names, seen from a 16-bit datapath. One predicted effect (a bf16 accuracy gain) was honestly falsified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/attnscale",
        "repo": "https://github.com/v-code01/attnscale",
        "prereg": "https://github.com/v-code01/attnscale/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "stochround",
      "title": "stochround",
      "claim": "Stochastic rounding -- and it's the only unbiased one. Round-to-nearest summing ones freezes at 256 forever (a bf16 weight can't learn a sub-ulp gradient); SR tracks the true sum, noisy per run but unbiased in the mean. Deterministic runs verified bit-for-bit across two languages.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/stochround",
        "repo": "https://github.com/v-code01/stochround",
        "prereg": "https://github.com/v-code01/stochround/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "normfootgun",
      "title": "normfootgun",
      "claim": "Real but conditional. RMSNorm wins big under naive bf16 accumulation (its target is well-conditioned; LayerNorm's variance isn't) and it can't express the one-pass cancellation footgun -- but a correctly fp32-accumulated two-pass LayerNorm ties it. An implementation gap, not a law.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/normfootgun",
        "repo": "https://github.com/v-code01/normfootgun",
        "prereg": "https://github.com/v-code01/normfootgun/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "kahansoftmax",
      "title": "kahansoftmax",
      "claim": "Not for the part that matters. The error splits into a large accumulation error -- which a compensated (Kahan) sum recovers 98-100% of in pure bf16 on diffuse distributions -- and a small term-quantization floor that only wider terms fix. Kahan in bf16 buys back almost all of it.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/kahansoftmax",
        "repo": "https://github.com/v-code01/kahansoftmax",
        "prereg": "https://github.com/v-code01/kahansoftmax/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "softmaxdual",
      "title": "softmaxdual",
      "claim": "Because fp16 and bf16 fail at softmax for opposite reasons: fp16 overflows past logit ~11, while bf16's 7-bit mantissa swamps the sum so the output doesn't even total 1. And the famous max-subtraction trick only rescues fp16, not bf16 -- hence fp32.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/softmaxdual",
        "repo": "https://github.com/v-code01/softmaxdual",
        "prereg": "https://github.com/v-code01/softmaxdual/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "gelufloor",
      "title": "gelufloor",
      "claim": "It depends on your precision. Its error is 7x below the bf16 rounding floor (free there) but level with the fp16 floor (not free), and it peaks in the shoulder, not the tails. A precision accounting, not a benchmark.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/gelufloor",
        "repo": "https://github.com/v-code01/gelufloor",
        "prereg": "https://github.com/v-code01/gelufloor/blob/HEAD/PREREG.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonbf16",
      "title": "neonbf16",
      "claim": "Round-to-nearest-even is exactly one bit more accurate than truncation (max rel error <=2^-8 vs <=2^-7) and free. But hand-writing a NEON kernel buys nothing (0.97-1.02x) -- the compiler already auto-vectorizes the bit-twiddle. Hand-SIMD only pays against an auto-vectorization barrier. asm-confirmed.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonbf16",
        "repo": "https://github.com/v-code01/neonbf16",
        "claims": "https://github.com/v-code01/neonbf16/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonbf16/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonbf16/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonbf16/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonswiglu",
      "title": "neonswiglu",
      "claim": "3.5-4.4x -- because the scalar sigmoid needs a non-inlinable expf call per element that blocks vectorization; replacing it with an inlined vector exp poly (~5e-8 accuracy) unblocks it. The gate-multiply fusion barely helps (compute-bound, not memory-bound). asm-confirmed, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonswiglu",
        "repo": "https://github.com/v-code01/neonswiglu",
        "claims": "https://github.com/v-code01/neonswiglu/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonswiglu/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonswiglu/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonswiglu/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonrmsnorm",
      "title": "neonrmsnorm",
      "claim": "Entirely the sum-of-squares reduction's 4-wide vector accumulator -- asm confirms the compiler won't reassociate an FP reduction at either precision, so NEON beats a float-accumulator scalar 2.5-3x. ~2x overall; rsqrt is free via 2 Newton steps. Independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonrmsnorm",
        "repo": "https://github.com/v-code01/neonrmsnorm",
        "claims": "https://github.com/v-code01/neonrmsnorm/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonrmsnorm/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonrmsnorm/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonrmsnorm/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "gpuqos",
      "title": "gpuqos",
      "claim": "BestEffort -- with the max kernel oom_score_adj (1000), making it the first OOM victim under memory pressure, because Kubernetes computes QoS from cpu/memory alone and ignores the GPU. Two independent signals (API qosClass + kernel oom_score_adj) on a real cluster: the scarce-GPU holder dies first.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/gpuqos",
        "repo": "https://github.com/v-code01/gpuqos",
        "claims": "https://github.com/v-code01/gpuqos/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/gpuqos/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/gpuqos/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/gpuqos/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "initbill",
      "title": "initbill",
      "claim": "No -- it stays billed to the pod for its whole lifetime, because reserved is max(init, regular). An init that asked for 4 GPUs on a workload needing 1 strands 3 of 4, idle and unusable by others, long after init completed. Real cluster, independently verified.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/initbill",
        "repo": "https://github.com/v-code01/initbill",
        "claims": "https://github.com/v-code01/initbill/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/initbill/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/initbill/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/initbill/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "fragfrontier",
      "title": "fragfrontier",
      "claim": "Permanently. With 4 free GPUs, a 4-GPU pod runs when they sit on one node but is Pending forever when split 2+2 -- the largest schedulable job is bounded by the most-free node (2), not the pool (4). Real 2-node cluster, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/fragfrontier",
        "repo": "https://github.com/v-code01/fragfrontier",
        "claims": "https://github.com/v-code01/fragfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/fragfrontier/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/fragfrontier/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/fragfrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "gangdeadlock",
      "title": "gangdeadlock",
      "claim": "Yes -- the scheduling atom is one Pod, so two gangs in a 2/2 split strand all 4 GPUs with 0 gangs runnable, and the default scheduler neither prevents nor breaks it. One atomic multi-GPU pod per job is structurally immune. Real cluster, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/gangdeadlock",
        "repo": "https://github.com/v-code01/gangdeadlock",
        "claims": "https://github.com/v-code01/gangdeadlock/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/gangdeadlock/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/gangdeadlock/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/gangdeadlock/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "topoblind",
      "title": "topoblind",
      "claim": "Nothing -- no device identity, no topology, not even a stored utilization figure; the control plane sees a fungible integer count. GPU 'utilization' is derived by summing pod requests, never stored. Four exact API-state facts on a real cluster, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/topoblind",
        "repo": "https://github.com/v-code01/topoblind",
        "claims": "https://github.com/v-code01/topoblind/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/topoblind/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/topoblind/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/topoblind/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "gpuhardwall",
      "title": "gpuhardwall",
      "claim": "No -- admission strictly precedes preemption. An exhausted namespace quota rejects the pod at creation, so a max-priority pod on a full node evicts nobody even though it would otherwise preempt 2 victims. Two hard walls, exact API-state counts, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/gpuhardwall",
        "repo": "https://github.com/v-code01/gpuhardwall",
        "claims": "https://github.com/v-code01/gpuhardwall/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/gpuhardwall/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/gpuhardwall/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/gpuhardwall/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "gpuoversub",
      "title": "gpuoversub",
      "claim": "Just the scheduler bin-packing an integer it can't see through: one GPU advertised as K units co-schedules exactly K 'dedicated'-GPU pods (there's no device-identity field in the API), and GPUs are integer-only with request==limit forced, unlike CPU. Real minikube, pre-registered, verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/gpuoversub",
        "repo": "https://github.com/v-code01/gpuoversub",
        "claims": "https://github.com/v-code01/gpuoversub/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/gpuoversub/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/gpuoversub/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/gpuoversub/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "hpalag",
      "title": "hpalag",
      "claim": "A median ~56 seconds -- ~40x longer than a pod takes to start -- because the delay is the metrics-scrape plus sync sampling loop, not pod startup. It scales only on the first scraped sample above target. Real minikube, pre-registered, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/hpalag",
        "repo": "https://github.com/v-code01/hpalag",
        "claims": "https://github.com/v-code01/hpalag/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/hpalag/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/hpalag/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/hpalag/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "dnsamp",
      "title": "dnsamp",
      "claim": "8 CoreDNS queries under the default ndots:5 -- 6 of them wasted cluster-domain NXDOMAINs, a 4x fan-out (from real CoreDNS logs). Both fixes -- a trailing-dot FQDN or dnsConfig ndots:1 -- cut it to 2. Real minikube, pre-registered, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/dnsamp",
        "repo": "https://github.com/v-code01/dnsamp",
        "claims": "https://github.com/v-code01/dnsamp/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/dnsamp/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/dnsamp/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/dnsamp/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "drain",
      "title": "drain",
      "claim": "Only if it finishes within terminationGracePeriodSeconds -- a 12s request dies at 4s grace but completes at 30s. Exit-on-SIGTERM always drops it, and a no-handler PID-1 server counterintuitively ignores SIGTERM entirely. Real minikube, pre-registered, independently verified.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/drain",
        "repo": "https://github.com/v-code01/drain",
        "claims": "https://github.com/v-code01/drain/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/drain/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/drain/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/drain/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "cfsthrottle",
      "title": "cfsthrottle",
      "claim": "Badly -- a 60ms-CPU request's p99 balloons to 9.7x at a 100m limit, tracking the cgroup's throttled time and vanishing when the quota fits the burst, while the pod uses under 6% of the node. CFS per-period throttling. Real minikube (cgroup v2), pre-registered, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/cfsthrottle",
        "repo": "https://github.com/v-code01/cfsthrottle",
        "claims": "https://github.com/v-code01/cfsthrottle/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/cfsthrottle/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/cfsthrottle/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/cfsthrottle/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "kubelb",
      "title": "kubelb",
      "claim": "No -- iptables balances new connections fairly (Gini 0.11) but conntrack pins each persistent connection to one pod, so replica coverage follows N(1-(1-1/N)^K) and stays below N even at 2x replicas. Keep-alive starves replicas. Real minikube, pre-registered, independently verified.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/kubelb",
        "repo": "https://github.com/v-code01/kubelb",
        "claims": "https://github.com/v-code01/kubelb/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/kubelb/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/kubelb/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/kubelb/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "holblock",
      "title": "holblock",
      "claim": "No -- continuous (iteration-level) batching inflates a concurrent 8-token request by a flat ~1.5x regardless of the long generation's length (128 vs 1024 tokens), versus the 11-52x it would wait if queued behind it. The measured case for iteration-level batching. Pre-registered, independently verified.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/holblock",
        "repo": "https://github.com/v-code01/holblock",
        "claims": "https://github.com/v-code01/holblock/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/holblock/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/holblock/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/holblock/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "ctxconflict",
      "title": "ctxconflict",
      "claim": "One false sentence overrides known facts 18-26% of the time; forceful repetition pushes it to 77-100%. The smaller model is more suggestible, and obscure facts fall first. Real llama.cpp, judge-free, pre-registered, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ctxconflict",
        "repo": "https://github.com/v-code01/ctxconflict",
        "claims": "https://github.com/v-code01/ctxconflict/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/ctxconflict/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/ctxconflict/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/ctxconflict/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "accumfrontier",
      "title": "accumfrontier",
      "claim": "Naive fp16 hits 85% error at vocab scale (fp32 stays under 1e-5); the cause is running-sum magnitude, and pairwise or Kahan summation rescue it where the values are representable. Pre-registered, independently verified against a double oracle in NumPy float16.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/accumfrontier",
        "repo": "https://github.com/v-code01/accumfrontier",
        "claims": "https://github.com/v-code01/accumfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/accumfrontier/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/accumfrontier/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/accumfrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonrope",
      "title": "neonrope",
      "claim": "Precomputing the sin/cos angles is a ~66x kernel lever and the only one that matters; hand-vectorizing buys nothing (the compiler auto-vectorizes and it's load-bound); and RoPE is under 0.01% of a decode step anyway. Pre-registered, one prediction falsified, independently verified.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonrope",
        "repo": "https://github.com/v-code01/neonrope",
        "claims": "https://github.com/v-code01/neonrope/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonrope/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonrope/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonrope/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "spacetax",
      "title": "spacetax",
      "claim": "It changes a byte-level-BPE model's tokenization and greedy output on 100% of prompts, and flips a third of factual answers wrong -- on a real llama.cpp server. One trailing space. Pre-registered, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/spacetax",
        "repo": "https://github.com/v-code01/spacetax",
        "claims": "https://github.com/v-code01/spacetax/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/spacetax/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/spacetax/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/spacetax/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "kvdivergence",
      "title": "kvdivergence",
      "claim": "Yes -- q8_0 KV changes the generated text on 83% of prompts, q4_0 on 100% (often from the start), with flash attention held constant. KV precision alone changes what the model says: 8-bit KV is not lossless at the token level. Controlled, pre-registered, code-reviewed.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/kvdivergence",
        "repo": "https://github.com/v-code01/kvdivergence",
        "claims": "https://github.com/v-code01/kvdivergence/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/kvdivergence/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/kvdivergence/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/kvdivergence/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "flopcross",
      "title": "flopcross",
      "claim": "The FFN owns ~88% of fixed per-token FLOPs, but attention grows linearly with context and overtakes it at exactly 1.5 x ffn_dim tokens (13,440 for the 1.5B, 7,296 for the 0.5B) -- a clean architectural constant, because d_model cancels. Go, exact, pre-registered.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/flopcross",
        "repo": "https://github.com/v-code01/flopcross",
        "claims": "https://github.com/v-code01/flopcross/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/flopcross/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/flopcross/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/flopcross/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "geluapprox",
      "title": "geluapprox",
      "claim": "No. The sigmoid approximation is ~10x faster than exact-erf but 43x less faithful than the tanh approximation (2% vs 0.05% activation error), so tanh is the speed/accuracy sweet spot. The error is provably symmetric in the |x|~2-3 elbow. C++, pre-registered, code-reviewed.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/geluapprox",
        "repo": "https://github.com/v-code01/geluapprox",
        "claims": "https://github.com/v-code01/geluapprox/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/geluapprox/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/geluapprox/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/geluapprox/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "rmsnorm",
      "title": "rmsnorm",
      "claim": "Faster AND more accurate: NEON RMSNorm is ~2x the scalar f32 loop, and its 4-lane tree reduction rounds less than a sequential sum (shown to be the reduction order, not FMA). f32 accumulation error grows with hidden dim; f64 stays flat. Pre-registered, code-reviewed.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/rmsnorm",
        "repo": "https://github.com/v-code01/rmsnorm",
        "claims": "https://github.com/v-code01/rmsnorm/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/rmsnorm/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/rmsnorm/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/rmsnorm/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "stragglerlat",
      "title": "stragglerlat",
      "claim": "A straggler taxes short-request latency (1.5x) via slot contention, not head-of-line blocking (shorts still finish first) -- but NOT more than an equal count of short requests: the matched control refutes the intuition. Real llama.cpp, pre-registered, code-reviewed.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/stragglerlat",
        "repo": "https://github.com/v-code01/stragglerlat",
        "claims": "https://github.com/v-code01/stragglerlat/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/stragglerlat/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/stragglerlat/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/stragglerlat/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "kvpaging",
      "title": "kvpaging",
      "claim": "Contiguous reservation wastes ~94% (worse the longer the context), so paging fits 18x-72x more concurrent sequences. Paging's own internal fragmentation is only ~block/2 tokens per sequence. Go, exact accounting, pre-registered.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/kvpaging",
        "repo": "https://github.com/v-code01/kvpaging",
        "claims": "https://github.com/v-code01/kvpaging/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/kvpaging/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/kvpaging/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/kvpaging/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "genentropy",
      "title": "genentropy",
      "claim": "Less certain -- intrinsic next-token entropy rises over a generation, the opposite of the 'grows more committed' intuition. The smaller model is more diffuse, and the rise isn't degeneration. Python, pre-registered, code-reviewed.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/genentropy",
        "repo": "https://github.com/v-code01/genentropy",
        "claims": "https://github.com/v-code01/genentropy/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/genentropy/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/genentropy/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/genentropy/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "ropeprecision",
      "title": "ropeprecision",
      "claim": "Yes -- naive f32 error grows linearly with position (~3e-3 at 128k tokens). Reducing the angle mod 2pi in f64 fixes it entirely (>10000x better). Rust, f64 oracle, pre-registered.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ropeprecision",
        "repo": "https://github.com/v-code01/ropeprecision",
        "claims": "https://github.com/v-code01/ropeprecision/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/ropeprecision/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/ropeprecision/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/ropeprecision/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "flashsoftmax",
      "title": "flashsoftmax",
      "claim": "It's numerically identical to two-pass at every context length -- the streaming rescale accumulates nothing -- but ~2.8x slower standalone. Its win is fusion (avoiding a second pass over memory), not raw speed. Pre-registered, long-double oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/flashsoftmax",
        "repo": "https://github.com/v-code01/flashsoftmax",
        "claims": "https://github.com/v-code01/flashsoftmax/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/flashsoftmax/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/flashsoftmax/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/flashsoftmax/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "bpelatency",
      "title": "bpelatency",
      "claim": "It scales exactly as predicted: naive ~L^2.0, heap ~L^1.1, and the naive/heap ratio grows unbounded -- 46-58x by L=1024 (a single ~1 KB piece). But naive still wins the common case (short real pieces), with a crossover in [8,64]. Validated against llama.cpp's tokenizer as a differential oracle; all predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/bpelatency",
        "repo": "https://github.com/v-code01/bpelatency",
        "claims": "https://github.com/v-code01/bpelatency/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/bpelatency/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/bpelatency/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/bpelatency/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "vocabstruct",
      "title": "vocabstruct",
      "claim": "One shared, byte-complete, merge-dominated object: byte-for-byte identical across the 1.5B and 0.5B (same 151,936 tokens, same hash), lossless, 99.81% learned BPE merges on a 256-token byte base. A full census, every number exact -- 3 of 4 predictions held (the length distribution wasn't unimodal).",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/vocabstruct",
        "repo": "https://github.com/v-code01/vocabstruct",
        "claims": "https://github.com/v-code01/vocabstruct/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/vocabstruct/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/vocabstruct/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/vocabstruct/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "gemvthreads",
      "title": "gemvthreads",
      "claim": "No, the surprise. The CPU GEMV scales near-linearly with cores and is compute-bound (implied bandwidth well below the ~216 GB/s ceiling); cache-resident and memory-resident matrices scale the same. The bandwidth wall is a system-level property, not in this kernel. All three pre-registered predictions held.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/gemvthreads",
        "repo": "https://github.com/v-code01/gemvthreads",
        "claims": "https://github.com/v-code01/gemvthreads/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/gemvthreads/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/gemvthreads/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/gemvthreads/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "fusedgemv",
      "title": "fusedgemv",
      "claim": "Yes -- ~2.3x faster (5.1->11.7 GFLOP/s), bit-for-bit identical to the unfused path, consistent across shapes. Fusing avoids streaming the dequantized weights out to memory and back. The capstone of the kernel series; all three pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/fusedgemv",
        "repo": "https://github.com/v-code01/fusedgemv",
        "claims": "https://github.com/v-code01/fusedgemv/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/fusedgemv/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/fusedgemv/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/fusedgemv/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "dequant",
      "title": "dequant",
      "claim": "More than 2x the scalar throughput, bit-exact against the scalar reference (no approximation), consistent across matrix size -- unpacking a whole 16-byte block per pass. This is the dequant step the roofline study flagged as the streaming cost. Standalone C++ ARM NEON; all three pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/dequant",
        "repo": "https://github.com/v-code01/dequant",
        "claims": "https://github.com/v-code01/dequant/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/dequant/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/dequant/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/dequant/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "layerprecision",
      "title": "layerprecision",
      "claim": "Yes, deliberately -- not random. Q4_K_M runs two precision tiers and puts exactly 50% of layers at the higher one (14/28 on the 1.5B, 12/24 on the 0.5B), protecting the front through to the back. The edge behavior is size-dependent: the 1.5B protects its last layer, the 0.5B doesn't. Both pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/layerprecision",
        "repo": "https://github.com/v-code01/layerprecision",
        "claims": "https://github.com/v-code01/layerprecision/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/layerprecision/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/layerprecision/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/layerprecision/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "bitbudget",
      "title": "bitbudget",
      "claim": "The feed-forward is the bulk (71% of the 1.5B's bytes at 4.84 bits/weight), but the embedding/output is quantized far higher (6.56-7.00 bits) and dominates the small model -- jumping from 20% of the 1.5B's bytes to 49% of the 0.5B's. Both pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/bitbudget",
        "repo": "https://github.com/v-code01/bitbudget",
        "claims": "https://github.com/v-code01/bitbudget/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/bitbudget/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/bitbudget/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/bitbudget/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "basefrontier",
      "title": "basefrontier",
      "claim": "Capability-gated: the 1.5B has real frontiers (decimal->binary to 4 bits, binary->decimal to 5) while the 0.5B is at complete floor -- it can't convert even a small number. And binary->decimal is the easier direction. Both pre-registered predictions held. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/basefrontier",
        "repo": "https://github.com/v-code01/basefrontier",
        "claims": "https://github.com/v-code01/basefrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/basefrontier/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/basefrontier/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/basefrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "kvmemory",
      "title": "kvmemory",
      "claim": "28 KB/token for the 1.5B, 12 KB/token for the 0.5B -- validated against the actual key-projection tensor, not estimated. A footnote at short context (0.06x weights at 2k) but it scales to model-size memory by long context. All three pre-registered predictions held; the config KV dim matched the tensor exactly.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/kvmemory",
        "repo": "https://github.com/v-code01/kvmemory",
        "claims": "https://github.com/v-code01/kvmemory/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/kvmemory/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/kvmemory/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/kvmemory/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "parallelscale",
      "title": "parallelscale",
      "claim": "Throughput doesn't monotonically saturate -- it plateaus then jumps (prediction 1 falsified). On the 1.5B: +33% at 2 slots, then only +3% at 4 and 8; the 0.5B keeps gaining (+64/+35/+11%). More slots also split the per-slot context (4096->1024). Predictions 2-4 held.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/parallelscale",
        "repo": "https://github.com/v-code01/parallelscale",
        "claims": "https://github.com/v-code01/parallelscale/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/parallelscale/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/parallelscale/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/parallelscale/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonselect",
      "title": "neonselect",
      "claim": "A branchless NEON argmax is ~8x the scalar scan (29->3.7us at 32k vocab), top-k by partial selection is 17-62x cheaper than a full sort, and the ratio grows with vocabulary size. This is the kernel behind why top-k is near-free. Standalone C++ ARM NEON; all three pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonselect",
        "repo": "https://github.com/v-code01/neonselect",
        "claims": "https://github.com/v-code01/neonselect/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonselect/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonselect/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonselect/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonsoftmax",
      "title": "neonsoftmax",
      "claim": "More than 2x the scalar throughput across vocab sizes (32k-152k), at negligible cost -- relative-L2 under 1e-4 from the polynomial exp -- and consistent across vocabulary size. Standalone C++ ARM NEON; all three pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonsoftmax",
        "repo": "https://github.com/v-code01/neonsoftmax",
        "claims": "https://github.com/v-code01/neonsoftmax/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonsoftmax/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonsoftmax/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonsoftmax/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "goodput",
      "title": "goodput",
      "claim": "There's a goodput knee at the slot count: throughput maxes at C=4 (211 tok/s on 1.5B, 572 on 0.5B), and C=8/12/16 add no throughput -- only latency, which grows roughly linearly (1.52s->4.54s on 1.5B). The smaller model has a higher ceiling but the same knee. All three predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/goodput",
        "repo": "https://github.com/v-code01/goodput",
        "claims": "https://github.com/v-code01/goodput/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/goodput/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/goodput/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/goodput/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "samplercost",
      "title": "samplercost",
      "claim": "top-p is the costly one; top-k and min-p are near free; putting top-k before top-p removes top-p's cost (it shrinks the candidate set first); and top-p's overhead is larger for the smaller model. All four pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/samplercost",
        "repo": "https://github.com/v-code01/samplercost",
        "claims": "https://github.com/v-code01/samplercost/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/samplercost/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/samplercost/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/samplercost/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "logprobcost",
      "title": "logprobcost",
      "claim": "A fixed per-token overhead -- +6% (1.5B), +10% (0.5B) -- that does NOT grow with k (that prediction was falsified): once you pay for any logprobs, asking for more is nearly free. Exact server timing.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/logprobcost",
        "repo": "https://github.com/v-code01/logprobcost",
        "claims": "https://github.com/v-code01/logprobcost/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/logprobcost/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/logprobcost/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/logprobcost/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "kvquant",
      "title": "kvquant",
      "claim": "No -- both the speedup and the drift-reduction predictions were falsified. Quantizing the KV cache makes decode *slower*: the dequant cost outweighs the fewer bytes read. A counter-intuitive, honest null.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/kvquant",
        "repo": "https://github.com/v-code01/kvquant",
        "claims": "https://github.com/v-code01/kvquant/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/kvquant/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/kvquant/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/kvquant/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "tokenasym",
      "title": "tokenasym",
      "claim": "An order of magnitude more: 12.8x for the 1.5B, 22.0x for the 0.5B (input 0.48/0.17ms vs output 6.18/3.69ms), and the gap grows with prompt length. Prefill is cheap; generation is where the bill is. All three pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/tokenasym",
        "repo": "https://github.com/v-code01/tokenasym",
        "claims": "https://github.com/v-code01/tokenasym/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/tokenasym/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/tokenasym/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/tokenasym/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "decodedrift",
      "title": "decodedrift",
      "claim": "Yes -- inter-token latency rises linearly with position (slope positive, CI excludes zero), it's material over a long generation, and the bigger model drifts faster in absolute terms. The decode-time complement to the prefill O(n^2) wall. All three predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/decodedrift",
        "repo": "https://github.com/v-code01/decodedrift",
        "claims": "https://github.com/v-code01/decodedrift/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/decodedrift/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/decodedrift/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/decodedrift/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "constraintcost",
      "title": "constraintcost",
      "claim": "Barely -- both pre-registered predictions were falsified. At matched token count the tax is ~1.02-1.04x for medium and complex grammars (only a simple grammar that closes early shows 1.79x). Constrained decoding is nearly free per token; the cost people fear isn't there.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/constraintcost",
        "repo": "https://github.com/v-code01/constraintcost",
        "claims": "https://github.com/v-code01/constraintcost/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/constraintcost/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/constraintcost/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/constraintcost/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "ctxprefill",
      "title": "ctxprefill",
      "claim": "Real and measurable: per-token prefill cost rises quadratically (positive coefficient, tight CI excluding zero) -- ms/token climbs 20-31% from ~10k to ~40k tokens. Prefill stops being linear well before your context window does. All three predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ctxprefill",
        "repo": "https://github.com/v-code01/ctxprefill",
        "claims": "https://github.com/v-code01/ctxprefill/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/ctxprefill/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/ctxprefill/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/ctxprefill/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "roofline",
      "title": "roofline",
      "claim": "Decode sits far below the roofline ridge (arithmetic intensity ~3 FLOP/byte vs 9.0), so it's memory-bandwidth-bound. On an M4 (221 GB/s STREAM ceiling) a single 1.5B stream already uses 67% of peak bandwidth; batching to 4 raises it to 92% and 207 tok/s but stays memory-bound -- it amortizes the weight read, it doesn't escape it. All three pre-registered predictions held.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/roofline",
        "repo": "https://github.com/v-code01/roofline",
        "claims": "https://github.com/v-code01/roofline/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/roofline/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/roofline/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/roofline/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "determinism",
      "title": "determinism",
      "claim": "Serial repeats are perfect (60/60 logit-identical), but concurrency breaks it: at 4 concurrent requests 0/8 are bit-identical -- only the sampled tokens match. Cross-batch and cache reuse perturb the logits too. So logprobs logged under load aren't reproducible, a hazard for calibration, perplexity, and reward scoring. Exact hashed-stream oracle with positive controls.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/determinism",
        "repo": "https://github.com/v-code01/determinism",
        "claims": "https://github.com/v-code01/determinism/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/determinism/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/determinism/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/determinism/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "neonkernel",
      "title": "neonkernel",
      "claim": "int8 SDOT is the dominant throughput lever -- >=3x the best f32 kernel -- at a cost of <1% accuracy (0.045% relative-L2 vs an f64 reference). Hand-NEON f32 is 3.1x the scalar loop, but for int8 the hand-SDOT kernel is only 1.46x scalar: the compiler already vectorizes int8 well. Standalone C++ ARM NEON, bit-reproducible.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/neonkernel",
        "repo": "https://github.com/v-code01/neonkernel",
        "claims": "https://github.com/v-code01/neonkernel/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/neonkernel/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/neonkernel/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/neonkernel/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "latencytail",
      "title": "latencytail",
      "claim": "Three regimes. Below the slot count, a batching tax -- per-token latency grows as the server decodes more active requests per step. Exactly at the slot count (C=4), a jitter spike: p99/p50 jumps to 2.24 (1.5B) and 2.67 (0.5B) versus ~1.2-1.3 elsewhere, the one concurrency where decode isn't smooth. Above it, queueing. Closed-loop C++ libcurl load generator.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/latencytail",
        "repo": "https://github.com/v-code01/latencytail",
        "claims": "https://github.com/v-code01/latencytail/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/latencytail/blob/HEAD/reproduce.sh",
        "prereg": "https://github.com/v-code01/latencytail/blob/HEAD/PREREG.md",
        "review": "https://github.com/v-code01/latencytail/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "ratio",
      "title": "ratio",
      "claim": "Magnitude dominates for both models -- accuracy roughly halves from small to large answers. A fractional unit price is a non-issue for the 1.5B (falsifying 'fractions are hard') but crushes the 0.5B at small magnitude (0.31->0.06). Capability-gated, and only visible once the magnitude confound is controlled. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ratio",
        "repo": "https://github.com/v-code01/ratio",
        "claims": "https://github.com/v-code01/ratio/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/ratio/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/ratio/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "anchoring",
      "title": "anchoring",
      "claim": "Anchoring is capability-gated. The 1.5B ignores it (pull slope 0.0003); the 0.5B gets dragged ~20% of the way toward the anchor (slope 0.196), more so the larger it is -- despite being told to ignore it. Exact oracle, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/anchoring",
        "repo": "https://github.com/v-code01/anchoring",
        "claims": "https://github.com/v-code01/anchoring/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/anchoring/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/anchoring/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "transitive",
      "title": "transitive",
      "claim": "It spots endpoints by surface pattern, not transitive inference. The 1.5B finds the tallest/shortest well above chance but is at chance for the second-tallest (gap 0.65); the 0.5B is at chance throughout. Exact MC oracle.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/transitive",
        "repo": "https://github.com/v-code01/transitive",
        "claims": "https://github.com/v-code01/transitive/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/transitive/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/transitive/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "ordereffect",
      "title": "ordereffect",
      "claim": "Both self-contradict on reversed comparisons (1.5B half the time, 0.5B 90%) -- and every contradiction is No-to-both: a negativity bias, not the acquiescence you'd assume. Judge-free consistency oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ordereffect",
        "repo": "https://github.com/v-code01/ordereffect",
        "claims": "https://github.com/v-code01/ordereffect/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/ordereffect/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/ordereffect/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "negation",
      "title": "negation",
      "claim": "Negation is capability-gated. A single 'not' halves the 0.5B (0.87->0.50) while the 1.5B is immune (1.00) -- until compound 'neither/nor' negation drops the 1.5B to 0.63 and the 0.5B to chance. Exact oracle, independent gold re-derivation.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/negation",
        "repo": "https://github.com/v-code01/negation",
        "claims": "https://github.com/v-code01/negation/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/negation/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/negation/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "clockmod",
      "title": "clockmod",
      "claim": "Directly, it's at chance past a 2-hour jump. Writing the mod-12 reduction out loud rescues the capable model completely (frontier 2->10, p=7e-31) and barely helps the weak one. A 5th confirmation that CoT helps scalar-state tasks. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/clockmod",
        "repo": "https://github.com/v-code01/clockmod",
        "claims": "https://github.com/v-code01/clockmod/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/clockmod/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/clockmod/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "revfrontier",
      "title": "revfrontier",
      "claim": "Reversal is pure tracking, no comparisons: it collapses after ~5 elements by dropping numbers, and CoT does not extend the frontier -- it hurts the capable model. A 2nd whole-list refutation of when step-by-step helps. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/revfrontier",
        "repo": "https://github.com/v-code01/revfrontier",
        "claims": "https://github.com/v-code01/revfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/revfrontier/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/revfrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "distractor",
      "title": "distractor",
      "claim": "Badly. One distractor sentence costs the 1.5B ~15% of its correct answers and the 0.5B ~half. A number-bearing distractor is no worse than a text-only one, so it's the irrelevant content, not stray digits. Exact oracle, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/distractor",
        "repo": "https://github.com/v-code01/distractor",
        "claims": "https://github.com/v-code01/distractor/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/distractor/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/distractor/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "vartrack",
      "title": "vartrack",
      "claim": "Not past 2-3 lines -- the indirection collapses it, not the arithmetic. Writing out each variable's value rescues the capable model almost completely but not the weak one. A 4th confirmation of when CoT helps. Exact executor oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/vartrack",
        "repo": "https://github.com/v-code01/vartrack",
        "claims": "https://github.com/v-code01/vartrack/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/vartrack/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/vartrack/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "datefrontier",
      "title": "datefrontier",
      "claim": "The 1.5B nails dates only ~2 weeks out, the 0.5B only 1 day. Its errors reveal it shifts months instead of counting days (30 days after Mar 15 -> Apr 15). Right nearby, wrong far out. Exact datetime oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/datefrontier",
        "repo": "https://github.com/v-code01/datefrontier",
        "claims": "https://github.com/v-code01/datefrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/datefrontier/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/datefrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "countcontrol",
      "title": "countcontrol",
      "claim": "Not without a counter -- it overshoots 'exactly 20' by tens and duplicates up to 44%. Numbering the list fixes it almost completely (McNemar p~1e-20). The counting analog of a running sum. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/countcontrol",
        "repo": "https://github.com/v-code01/countcontrol",
        "claims": "https://github.com/v-code01/countcontrol/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/countcontrol/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/countcontrol/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "sortfrontier",
      "title": "sortfrontier",
      "claim": "The failure mode shifts from comparison errors to tracking errors -- dropped or invented numbers, ~97% by length 16. And CoT doesn't help sorting; it hurts the small model. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/sortfrontier",
        "repo": "https://github.com/v-code01/sortfrontier",
        "claims": "https://github.com/v-code01/sortfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/sortfrontier/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/sortfrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "sycophancy",
      "title": "sycophancy",
      "claim": "Both do, but differently: the 0.5B is a suggestible follower (adopts the user's wrong answer), the 1.5B an unstable contrarian (caves under any challenge, most when affirmed). The control dissociates the two. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/sycophancy",
        "repo": "https://github.com/v-code01/sycophancy",
        "claims": "https://github.com/v-code01/sycophancy/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/sycophancy/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/sycophancy/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "depthfrontier",
      "title": "depthfrontier",
      "claim": "A working-memory limit -- both models fail past 3-4 terms. CoT rescues the capable model almost completely (frontier 4->16) but barely the weak one. Self-generated exact ground truth.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/depthfrontier",
        "repo": "https://github.com/v-code01/depthfrontier",
        "claims": "https://github.com/v-code01/depthfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/depthfrontier/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/depthfrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "arithfrontier",
      "title": "arithfrontier",
      "claim": "Multiplication cliffs at 3-4 digits before addition does, the frontier shrinks with model size, and CoT extends it -- the opposite of its effect on retrieval multiple choice. Self-generated exact ground truth.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/arithfrontier",
        "repo": "https://github.com/v-code01/arithfrontier",
        "claims": "https://github.com/v-code01/arithfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/arithfrontier/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/arithfrontier/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "riskcoverage",
      "title": "riskcoverage",
      "claim": "Yes. A 2x2 (size x ARC difficulty) selective-prediction study: confidence ranks correctness (AUROC 0.68-0.91), so abstention lifts accuracy in every regime -- even where calibration is poor. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/riskcoverage",
        "repo": "https://github.com/v-code01/riskcoverage",
        "claims": "https://github.com/v-code01/riskcoverage/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/riskcoverage/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/riskcoverage/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "calibration",
      "title": "calibration",
      "claim": "No -- systematically overconfident, measured from exact top-logprobs. A 2x2 (size x ARC difficulty) study: miscalibration compounds with both smaller size and harder task.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/calibration",
        "repo": "https://github.com/v-code01/calibration",
        "claims": "https://github.com/v-code01/calibration/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/calibration/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/calibration/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "cotmc",
      "title": "cotmc",
      "claim": "Hurts. A 2x2 (size x ARC difficulty) study: CoT is a net negative, flipping ~2x more correct answers wrong than it rescues (pooled McNemar p=0.005). Exact oracle.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/cotmc",
        "repo": "https://github.com/v-code01/cotmc",
        "claims": "https://github.com/v-code01/cotmc/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/cotmc/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/cotmc/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "positionbias",
      "title": "positionbias",
      "claim": "Yes, and it scales inversely with capability. A cross-model ARC-Easy rotation study: the weak model systematically avoids the last option. Exact oracle.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/positionbias",
        "repo": "https://github.com/v-code01/positionbias",
        "claims": "https://github.com/v-code01/positionbias/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/positionbias/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/positionbias/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "selfconsistency",
      "title": "selfconsistency",
      "claim": "Cross-model, exact-match oracle: it beats greedy on the 1.5B (+13 points, p=0.002) but the 0.5B's gain isn't significant. The benefit traces to answer-entropy -- the mechanism, not just the score.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/selfconsistency",
        "repo": "https://github.com/v-code01/selfconsistency",
        "claims": "https://github.com/v-code01/selfconsistency/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/selfconsistency/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/selfconsistency/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "cotbudget",
      "title": "cotbudget",
      "claim": "On two sizes, a low budget inverts the size ranking -- the smaller model wins when reasoning is starved. Exact-match oracle, independently verified.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/cotbudget",
        "repo": "https://github.com/v-code01/cotbudget",
        "claims": "https://github.com/v-code01/cotbudget/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/cotbudget/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/cotbudget/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "fewshotcurve",
      "title": "fewshotcurve",
      "claim": "No significant gain on either Qwen2.5-1.5B or 0.5B (McNemar p=0.22, p=1.0) at 4-16x the prompt-token cost -- the near-null transfers across sizes. First cross-model-validated factory study. Honest negative.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/fewshotcurve",
        "repo": "https://github.com/v-code01/fewshotcurve",
        "claims": "https://github.com/v-code01/fewshotcurve/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/fewshotcurve/blob/HEAD/reproduce.sh",
        "review": "https://github.com/v-code01/fewshotcurve/blob/HEAD/REVIEW.md"
      }
    },
    {
      "type": "experiment",
      "id": "prefillcache",
      "title": "prefillcache",
      "claim": "Warm prefill stays flat at ~8-11ms while cold grows linearly, so a reused shared prefix goes from an 8x speedup at 114 tokens to 81x at 1841 -- 88-99% of prefill eliminated, nearly free after the first request.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/prefillcache",
        "repo": "https://github.com/v-code01/prefillcache",
        "claims": "https://github.com/v-code01/prefillcache/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/prefillcache/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "batchscale",
      "title": "batchscale",
      "claim": "No -- it's non-monotone with a regime change. Throughput plateaus ~220 tok/s through concurrency 8, then jumps to 522 at 16. Concurrency 8, a partial batch, is the worst place to operate: mediocre throughput and the highest latency.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/batchscale",
        "repo": "https://github.com/v-code01/batchscale",
        "claims": "https://github.com/v-code01/batchscale/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/batchscale/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "promptbrittle",
      "title": "promptbrittle",
      "claim": "On GSM8K, semantically-equivalent formats swing accuracy 25 points (0.42 to 0.68) on the same questions (McNemar p 0.006), with reasoning elicitation the biggest lever. The wording is a hyperparameter.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/promptbrittle",
        "repo": "https://github.com/v-code01/promptbrittle",
        "claims": "https://github.com/v-code01/promptbrittle/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/promptbrittle/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "tokentax",
      "title": "tokentax",
      "claim": "The tokenization tax, on a real tokenizer: numbers cost 5x the tokens-per-character of English prose, JSON 2.4x, math 2.2x, code 1.75x, non-English 1.5x. Your context budget is content-dependent.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/tokentax",
        "repo": "https://github.com/v-code01/tokentax",
        "claims": "https://github.com/v-code01/tokentax/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/tokentax/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "weightquant",
      "title": "weightquant",
      "claim": "Q4_K_M is the Pareto sweet spot -- near-lossless at 32% of f16 size. Everything above it is lossless within noise; Q2_K is a cliff at +90% perplexity. The rate-distortion frontier, measured on a real model.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/weightquant",
        "repo": "https://github.com/v-code01/weightquant",
        "claims": "https://github.com/v-code01/weightquant/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/weightquant/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "tempfrontier",
      "title": "tempfrontier",
      "claim": "Self-consistency needs temperature -- no benefit at temp 0. Majority-voting k samples gains +16 points at temp 0.8-1.0 while single-sample accuracy stays flat. The exact temperature tradeoff on GSM8K.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/tempfrontier",
        "repo": "https://github.com/v-code01/tempfrontier",
        "claims": "https://github.com/v-code01/tempfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/tempfrontier/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "ctxprobe",
      "title": "ctxprobe",
      "claim": "On a real 32k-window model, retrieval degrades past ~17k and shows a clean lost-in-the-middle U-shape -- compounding to 0.30 at 30k-middle versus 0.90 at the start. Length and burial stack.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ctxprobe",
        "repo": "https://github.com/v-code01/ctxprobe",
        "claims": "https://github.com/v-code01/ctxprobe/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/ctxprobe/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "specdomain",
      "title": "specdomain",
      "claim": "Acceptance is strongly domain-gated -- 32% on chat, 85% on math -- but on a 0.5B/1.5B pair speculation is a net loss: the target-to-draft cost gap is too small to pay for the misses. Honest negative.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/specdomain",
        "repo": "https://github.com/v-code01/specdomain",
        "claims": "https://github.com/v-code01/specdomain/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/specdomain/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "kvbits",
      "title": "kvbits",
      "claim": "No. On real llama.cpp the key cache needs >=8 bits while the value cache stays lossless at 4-bit. Asymmetric Kq8/Vq4 buys a 59% KV reduction at <1% perplexity; symmetric 4-bit is catastrophic.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/kvbits",
        "repo": "https://github.com/v-code01/kvbits",
        "claims": "https://github.com/v-code01/kvbits/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/kvbits/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "admitctl",
      "title": "admitctl",
      "claim": "A lot. KV-slot-aware SJF admission in front of a real llama.cpp server cuts short-request p99 ~16x at matched throughput under overload, without starving long requests. FCFS leaves that on the table.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/admitctl",
        "repo": "https://github.com/v-code01/admitctl",
        "claims": "https://github.com/v-code01/admitctl/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/admitctl/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "effortfrontier",
      "title": "effortfrontier",
      "claim": "Honest negative: on GSM8K against the exact gold label, a cheap greedy allocation does not beat uniform at matched budget -- despite ~9x oracle headroom. The gain is real; a simple policy doesn't reach it.",
      "result": "null",
      "verify": {
        "detail": "https://vanshverma.com/lab/effortfrontier",
        "repo": "https://github.com/v-code01/effortfrontier",
        "claims": "https://github.com/v-code01/effortfrontier/blob/HEAD/claims.toml",
        "reproduce": "https://github.com/v-code01/effortfrontier/blob/HEAD/reproduce.sh"
      }
    },
    {
      "type": "experiment",
      "id": "doobspec",
      "title": "doobspec",
      "claim": "Exact measurement of the future-validity bias greedy constrained decoding introduces, plus a boundary on whether a depth-1 correction actually buys JSON-Schema validity at CPU scale -- where it earns its cost and where it doesn't.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/doobspec",
        "repo": "https://github.com/v-code01/doobspec",
        "claims": "https://github.com/v-code01/doobspec/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "toolfetch",
      "title": "toolfetch",
      "claim": "The measured retrieve-vs-inject frontier on a CPU-local model: how many tools you can put in context before it stops picking the right one. Real ToolRet labels, exact-match scoring, no LLM judge.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/toolfetch",
        "repo": "https://github.com/v-code01/toolfetch"
      }
    },
    {
      "type": "experiment",
      "id": "prefixfair",
      "title": "prefixfair",
      "claim": "The cache-hit vs cross-tenant service-gap Pareto frontier across five routing policies, measured on real llama.cpp backends. Honest either way.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/prefixfair",
        "repo": "https://github.com/v-code01/prefixfair",
        "claims": "https://github.com/v-code01/prefixfair/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "crosskv",
      "title": "crosskv",
      "claim": "On a real 12B transformer, coupling the eviction and quantization budgets beats separable allocation held-out at equal budget for SnapKV, and is a wash for H2O. The interaction is real but evictor-dependent.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/crosskv",
        "repo": "https://github.com/v-code01/crosskv",
        "claims": "https://github.com/v-code01/crosskv/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "funnelscan",
      "title": "funnelscan",
      "claim": "A NEON group-probe funnel table sustains 99.9% load with bounded p99.9 probes, in a smaller footprint than a SwissTable forced to resize.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/funnelscan",
        "repo": "https://github.com/v-code01/funnelscan",
        "claims": "https://github.com/v-code01/funnelscan/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "circ-das",
      "title": "circ-das",
      "claim": "At high rate, block-circulant beats 2D-RS distance. First implementation and honest measurement, with a NEON GF(2^8) encoder and a coded-Merkle DAS sampler.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/circ-das",
        "repo": "https://github.com/v-code01/circ-das",
        "claims": "https://github.com/v-code01/circ-das/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "ribbonguard",
      "title": "ribbonguard",
      "claim": "Yes. A NEON blocked filter fused with a skew-adaptive false-positive suppressor holds the no-false-negative invariant, exhaustively checked, while cutting false positives where the skew concentrates.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/ribbonguard",
        "repo": "https://github.com/v-code01/ribbonguard",
        "claims": "https://github.com/v-code01/ribbonguard/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "calibann",
      "title": "calibann",
      "claim": "It's silently unsafe. A calibrated, safety-gated gate on a binary-quantized ANN core turns served-error into a target you control instead of a number you hope about.",
      "result": "confirmed",
      "verify": {
        "detail": "https://vanshverma.com/lab/calibann",
        "repo": "https://github.com/v-code01/calibann",
        "claims": "https://github.com/v-code01/calibann/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "experiment",
      "id": "cdcneon",
      "title": "cdcneon",
      "claim": "SeqCDC on a NEON fast path hits ~19 GiB/s on an M4. Gear stays the default: it dedups better and degrades more gracefully. blake3 content-addressed store underneath.",
      "result": "mixed",
      "verify": {
        "detail": "https://vanshverma.com/lab/cdcneon",
        "repo": "https://github.com/v-code01/cdcneon",
        "claims": "https://github.com/v-code01/cdcneon/blob/HEAD/claims.toml"
      }
    },
    {
      "type": "product",
      "id": "keel",
      "title": "Keel",
      "claim": "An in-browser, WebGPU-accelerated RAG platform that runs entirely client-side. Live in production.",
      "verify": {
        "live": "https://keel.vanshverma.com"
      }
    },
    {
      "type": "open-source",
      "id": "ledge",
      "title": "Ledge",
      "claim": "Git-compatible storage engine rebuilt for agent workloads: faster clone and smaller packs than git on the same source, BLAKE3 content addressing, sharded Raft replication with a TLA+-verified consensus core (5 modules, model-checked), driven by a stock git client. Source-available, in Rust.",
      "verify": {
        "repo": "https://github.com/v-code01/ledge"
      }
    },
    {
      "type": "open-source",
      "id": "phantom",
      "title": "PHANTOM",
      "claim": "Multi-agent LLM serving for Apple Silicon unified memory. Eliminates PCIe weight copies; DualRadixTree copy-on-write KV cache; MESI coherence formally specified in TLA+.",
      "verify": {
        "repo": "https://github.com/v-code01/phantom"
      }
    },
    {
      "type": "open-source",
      "id": "nemesis",
      "title": "NEMESIS",
      "claim": "Autonomous GPU cluster orchestration. Replaces on-call SRE judgment with specialized agents that perceive hardware degradation before failure. Topology-aware scheduling; heals running training jobs without restart via NCCL 2.27 Communicator Shrink. Validated against the Alibaba Cluster Trace dataset.",
      "verify": {
        "repo": "https://github.com/v-code01/nemesis"
      }
    },
    {
      "type": "open-source",
      "id": "tasft",
      "title": "TASFT",
      "claim": "Task-Aware Sparse Fine-Tuning. Co-trains LoRA adapters with block-sparse attention gates for 2-5x decode throughput at 70-85% sparsity. 676 tests passing.",
      "verify": {
        "repo": "https://github.com/v-code01/tasft"
      }
    },
    {
      "type": "open-source",
      "id": "kubebalance",
      "title": "KubeBalance",
      "claim": "Kubernetes scheduler plugin — network topology-aware, cost-based, performance-driven pod placement.",
      "verify": {
        "repo": "https://github.com/v-code01/kubebalance"
      }
    },
    {
      "type": "open-source",
      "id": "airflowllm",
      "title": "AirflowLLM",
      "claim": "Generate production-ready Airflow DAGs from natural language. 45 tokens/sec on CodeLlama 7B, ~700ms on an M2 Pro, fully local — no API calls.",
      "verify": {
        "repo": "https://github.com/v-code01/airflow-llm-orchestrator"
      }
    },
    {
      "type": "open-source",
      "id": "edgetrain",
      "title": "EdgeTrain",
      "claim": "Neural-network training in the browser via WebGPU compute shaders. No server, no Python.",
      "verify": {
        "repo": "https://github.com/v-code01/edgetrain"
      }
    }
  ]
}