Some DNA changes, called synonymous variants, alter a gene's spelling without changing the protein it encodes. They were long treated as harmless, but they can still cause disease. They do this by breaking how the RNA copy of the gene is cut and joined (splicing), how that RNA folds, or how fast the protein is built. Neural models now score these variants. A variant's score is the difference between the model's output on the normal ("reference") sequence and on the variant ("alternate") sequence. For synonymous variants that difference is small.
Meanwhile, AI agents now rewrite the low-level GPU code (kernels) that runs these models and report speedups of 2–8×. They accept a rewritten kernel if its outputs match the original within a numerical tolerance on random inputs. This note asks whether that acceptance test protects the quantity clinicians actually use, which is the small reference-minus-alternate difference that decides whether a variant is flagged as pathogenic.
The proposal is a paired-difference fidelity test. We measure how often agent-optimized kernels flip the classification of known variants, broken down by variant type. We then put that measure into the kernel search itself as the acceptance criterion and the reward. The expected outcome is a speed–fidelity frontier for synonymous variant scoring, plus a kernel acceptance rule that preserves clinical rankings.
Core Claim
We claim that tolerance-based correctness checks certify kernels that preserve activations but not variant rankings. We further claim that the damage is concentrated on synonymous variants.
Two findings motivate this. First, GDTR measured how many layers a genomic model's internal representation takes to stabilize. Across 4,023 ClinVar variants in Evo 2 7B, synonymous substitutions stabilize at the deepest layers. Their signal is therefore carried latest in the network, where numerical error has accumulated the most. Second, benchmark correctness checks in KernelBench and TritonBench compare outputs against reference code on sampled inputs. They say nothing about differences between two nearly identical inputs.
The stakes are clinical. Chen et al. report that synonymous coding SNPs have disease associations about as strong as protein-changing ones (median odds ratio 1.70 vs 1.72). Misranking them is therefore a real diagnostic cost, not a rounding curiosity.
Define the variant effect score as $\Delta_v = s(x_v^{alt}) - s(x_v^{ref})$, where $s$ is a model's scalar output (log-likelihood or splice probability) and $x_v$ is the sequence window around variant $v$. For an optimized kernel producing $\tilde{\Delta}_v$, we define fidelity on a labeled variant set $V$ at clinical threshold $\tau$ as the flip rate:
$$F = \frac{1}{|V|}\sum_{v \in V} \mathbf{1}\left[\operatorname{sign}(\tilde{\Delta}_v - \tau) \neq \operatorname{sign}(\Delta_v - \tau)\right]$$
We report $F$ together with the rank correlation between $\tilde{\Delta}$ and $\Delta$. A kernel is fidelity-accepted if $F$ is no larger than the flip rate produced by run-to-run nondeterminism of the reference implementation itself.
Why This Must Run Per Patient
A reviewer's first objection is that nobody needs fast kernels here, because every possible single substitution can be scored once offline and stored. For isolated variants on the reference genome, that objection is correct.
It fails in two cases where the sequence context is specific to the patient. Nearby variants on the same chromosome copy (a phased haplotype) change the surrounding codons and splicing signals. Long-read phased assemblies such as those of Sui et al. make these haplotypes available. Tissue-conditioned models such as SpliceTransformer multiply the work across 15 tissues over a 10,000-base context. In both cases the scores must be computed per patient, so inference cost and kernel optimization genuinely matter.
Research Program
Ensemble variant calling enters in two places.
The first is the downstream decision. We build a synonymous pathogenicity score by fusing mechanism-specific predictors, in the style of SomaticSeq. SomaticSeq trains a boosted decision-tree classifier over five callers and more than 70 features, and reports F1 of 90.5% versus 62.4% for the best single caller, MuTect, in a DREAM Challenge setting. Our fused predictors are:
- a splicing score from SpliceTransformer;
- a codon-context score from EnCodon in the cdsFM suite, a RoFormer that uses rotary position embeddings (RoPE);
- an RNA-structure and protein-binding score from PrismNet;
- an overlapping-reading-frame flag derived from POLG ORF-Y-style annotations.
We treat the fusion as the thing whose decisions must be preserved. Fusion can amplify or dampen per-model drift, and we measure which happens.
The second place borrows the consensus logic of variant calling. We run the same variant through several independently optimized kernel implementations, possibly on different hardware. Variants whose scores disagree across implementations are flagged as numerically fragile, much as caller disagreement flags sequencing artifacts.
Hardware optimization supplies the method we stress-test. We apply KernelBand and KernelFoundry to the hot operators of EnCodon and SpliceTransformer: RoPE, attention, normalization and fused feed-forward blocks. KernelBand uses a multi-armed bandit steered by profiler measurements. KernelFoundry uses evolutionary quality-diversity search, and its best case study was a RoPE kernel 7.9× faster than PyTorch in Llama 3.2 1B. We run each search twice, once with standard tolerance acceptance and once with fidelity acceptance plus a flip-rate penalty in the reward.
This connects to a known failure of these systems. Dr. Kernel and CUDA-L1 document reward hacking in kernel reinforcement learning. Our claim is that tolerance checks leave open a specific, clinically relevant hole of this kind.
Baselines
The naive reference point is the unoptimized model: PyTorch eager in FP32 with deterministic algorithms enabled. It defines $\Delta_v$ and gives us the run-to-run noise floor for $F$. A second naive point is torch.compile with BF16 autocast. This is what a practitioner would do without agents, and it tests whether plain reduced precision already causes the flips we attribute to agent kernels.
The strongest speed competitors are KernelBand and KernelFoundry, run with their published search procedures and tolerance acceptance. KernelBand reports up to a 1.91× geometric-mean speedup on A100 over TritonBench-G. KernelFoundry reports a 2.3× average speedup on KernelBench SYCL tasks. For fairness, both arms (tolerance-accepted and fidelity-accepted) get the same LLM, the same dollar budget per kernel (KernelBand's $0.50 setting), the same number of profiler calls and the same GPUs. We plan A100, H20, RTX 4090 and Intel Arc B580 for SYCL.
On the fidelity side we found no reported result on Lacuna for classification flip rates or rank preservation of variant scores under optimized kernels. On the pathogenicity side we found no reported AUROC on Lacuna for EnCodon or SpliceTransformer restricted to ClinVar synonymous variants. We will compute both ourselves under the reference implementation.
The key ablation keeps everything in the fidelity-aware search except the pairing. It validates on reference and alternate sequences separately rather than on their difference. This isolates whether the paired-difference criterion is what matters, as opposed to simply using genomic inputs instead of random ones.
We count a result as beating the baselines only under one condition. The fidelity-accepted kernels must keep flip rate at the noise floor on ClinVar synonymous variants while retaining at least most of the tolerance-accepted speedup on the same hardware, and tolerance-accepted kernels must show flip rates measurably above that floor.
Why not just…?
Why not just precompute scores offline and skip kernel optimization entirely? For isolated reference-context substitutions this is the right answer, and we will say so. The proposal's relevance depends on haplotype- and tissue-specific scoring. We will quantify how many ClinVar synonymous variants have another variant within the model's context window in phased long-read haplotypes, and how much $\Delta_v$ changes when that context is included. If context rarely changes $\Delta_v$, the practical case for per-patient fast inference collapses. The fidelity finding would then matter only for model developers retraining or re-scoring databases.
Why not just rely on error cancellation, since reference and alternate go through the same kernel? This is the most serious threat. If numerical error is common-mode, meaning nearly identical for two inputs that differ by one base, it cancels in $\tilde{\Delta}_v$ and tolerance checks are sufficient. The ablation above tests exactly this. We will also measure how error in the reference and alternate outputs correlates, by layer and by operator. If flip rates for tolerance-accepted kernels sit at the noise floor, we report a negative result: current acceptance is adequate for variant scoring. That is still a useful finding for anyone deploying these models.
Why not just use FP32 and forgo aggressive optimization? Speed matters here. SpliceTransformer runs over 10,000-base windows in 15 tissues, and per-patient haplotype scoring multiplies that cost. The experiment reports the full speed–fidelity frontier, so a reader can see whether the fidelity-safe kernels recover most of the speedup. If they recover almost none, FP32 wins and we say so.
Why not just distill a small synonymous-effect model instead? Distillation trades fidelity to the teacher for speed through a different route. It also loses the tissue and mechanism breadth that the fused score provides. We include a distilled EnCodon student, trained with the same compute as the kernel search, on the same frontier as a competing point.
Proposed Experiments
The evaluation sets are:
- ClinVar synonymous variants labeled pathogenic/likely pathogenic versus benign/likely benign, with missense variants as the comparison class;
- the 1,054 synonymous membrane-protein expression measurements from cdsFM;
- MaveDB studies used by cdsFM;
- the 41 POLG variants reclassified via ORF-Y, as a stress set where the label depends on a hidden reading frame.
For haplotype context we use phased assemblies where accessible. Otherwise we construct haplotypes by placing common nearby variants in cis.
For every model × hardware × kernel-arm combination we report four quantities: speedup over eager execution, flip rate $F$ at the clinical thresholds each model's authors use, Spearman correlation of $\tilde{\Delta}$ with $\Delta$, and the change in AUROC of the fused synonymous score. Each is reported separately for synonymous and missense variants.
The decisive check is a comparison of two effects. One is the synonymous-minus-missense difference in flip rate under tolerance-accepted kernels. The other is that same difference under fidelity-accepted kernels. A positive synonymous excess that disappears under fidelity acceptance, at modest speed cost, supports the claim.
A secondary check tests whether the consensus flag is useful. We ask whether variants on which independently optimized implementations disagree are enriched among the classification flips. If they are, the ensemble's disagreement can serve as a runtime warning at no labeling cost.
References
- GDTR: Layer-wise Settling Depth Reveals Biological Grammar in Genomic Foundation Models
- KernelBench: Can LLMs Write Efficient GPU Kernels?
- TritonBench: Benchmarking Large Language Model Capabilities for Generating Triton Operators
- Non-Synonymous and Synonymous Coding SNPs Show Similar Likelihood and Effect Size of Human Disease Association
- Using the linear references from the pangenome to discover missing autism variants
- SpliceTransformer predicts tissue-specific splicing linked to human diseases
- An ensemble approach to accurately detect somatic mutations using SomaticSeq
- A Suite of Foundation Models Captures the Contextual Interplay Between Codons
- Predicting dynamic cellular protein–RNA interactions by deep learning using in vivo RNA structures
- Evidence for a novel overlapping coding sequence in POLG initiated at a CUG start codon
- KernelBand: Steering LLM-based Kernel Optimization via Hardware-Aware Multi-Armed Bandits
- KernelFoundry: Hardware-Aware Evolutionary GPU Kernel Optimization
- Dr. Kernel: Reinforcement Learning Done Right for Triton Kernel Generations
- CUDA-L1: Improving CUDA Optimization via Contrastive Reinforcement Learning