Pith. sign in

REVIEW 4 major objections 4 minor 18 references

A Contract-Grade Verifier for LLM-Generated GPU Kernels, and a Native Blackwell Backward for the Gated-Linear-Recurrence Family

T0 review · 4 major / 4 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that the standard one-shot closeness check certifies thousands of LLM-generated GPU kernels that are still broken, and that a twelve-gate tolerance-free verifier exposes the gap.

desk verdict A serious, well-defended audit with a real artifact, but the tolerance-free floor is contract-dependent because the reference semantics are asserted rather than benchmarked. read the letter →

arxiv 2608.12700 v1 pith:W7LMGYRI submitted 2026-08-13 cs.LG cs.ARcs.DC

Rishi Shah , Rishav Shrestha This is my paper · ORCID
classification cs.LGcs.ARcs.DC
keywords GPUkernelgenerationLLM-generatedcodecorrectnessverificationtolerance-freecontractsfloating-pointsemanticsgatedlinearrecurrenceBlackwelltcgen05benchmarks
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Correctness reports for LLM-generated GPU kernels rest on a single weak test: a few random inputs at one fixed shape, accepted if the output is close to a reference. This paper builds a twelve-gate verifier that checks properties a correct kernel must have, several of them with no numerical tolerance at all, and runs it over 2,638 kernels that a public system's own harness had already accepted as correct. It finds 39.5% fail a tolerance-free gate and 62.1% carry at least one contract violation, while the standard check certifies 1,487 kernels the verifier rejects against only 14 the other way. The same verifier also certifies the paper's own artifact, a native Blackwell tensor-core training backward for the gated-linear-recurrence family, verified independently against a double-precision oracle, which serves as a positive control that the battery is not tuned to fail foreign code.

What carries the argument

The load-bearing instrument is a twelve-gate contract verifier that operationalizes a correctness taxonomy for GPU kernels. Several gates are tolerance-free—exact-mask or byte-equality comparisons for non-finite propagation (EXC-01), subnormal flush-to-zero behavior (EXC-02), and run-to-run determinism and buffer aliasing (ORD-02)—so no threshold can excuse a failure; the remaining gates use error-model-derived bounds, such as $\text{atol} \approx 4\varepsilon\sqrt{N}\cdot\text{scale}$ for reordered reductions. On the systems side, the central object is the gated linear recurrence $S_t = (I-k_t(b_t\odot k_t)^\top)\operatorname{Diag}(e^{g_t})S_{t-1} + k_t(w_t\odot v_t)^\top$, whose backward splits into two hard stages: a reverse-time inter-chunk state scan and a triangular-inverse vector-Jacobian product. The native kernel keeps the state gradient $dS$ resident in tensor memory across the whole reverse scan, handling the 512-column tensor-memory lifecycle that a known compiler failure trips when a kernel requests 544 columns.

What would settle it

Re-run the tolerance-free gates on the 1,043 failing kernels under a reference that follows the kernel's declared fast-math mode, allowing flush-to-zero subnormal handling and non-propagating NaNs, and then count how many of the 868 EXC-01 and 238 EXC-02 failures still reproduce. If a substantial share pass under that reference, the claimed 39.5% floor is an artifact of the fixed reference semantics rather than a property of the kernels.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is a measured rigor gap: among kernels a public generation system had accepted as correct, 62.1% violate at least one of twelve correctness contracts and 39.5% fail a tolerance-free gate, meaning no choice of acceptance threshold can explain the failure away. The modal defect is a kernel silently returning an ordinary finite number where the reference returns a NaN or infinity, which turns a detectable training error into silent data corruption. The paper defends the rates with a positive control that passes all seven trusted kernels, a threshold-calibration sweep, 98.5% agreement with the benchmark's own correctness code, and a stratified hand-audit, and it reports a second, native-CUDA corpus showing a weaker but related pattern. Its second claim is that a single native Blackwell tensor-core backward for the gated-linear-recurrence family, including the reverse-state scan stage other implementations still run in a fallback, is correct: it matches a double-precision oracle to about $3.3\times10^{-3}$ end to end, is bit-for-bit deterministic, and trains five family members through the real kernels.

Load-bearing premise

The audit's headline rates assume that the high-precision reference loops—including their exact NaN/Inf propagation and subnormal flush-to-zero behavior—are the only legitimate contract for every kernel, so a kernel that intentionally targets different but sanctioned IEEE/GPU fast-math semantics would be counted as broken even when it is not.

Editorial extensions

If this is right

  • If the audit is correct, published correctness rates for LLM-generated GPU kernels are substantially overstated: the standard check accepts 1,487 kernels the verifier rejects, versus only 14 in the reverse direction.
  • A small set of tolerance-free contracts—non-finite propagation, determinism, and shape polymorphism—would close most of the gap, since 958 of the disputed acceptances fail on a tolerance-free gate.
  • The gated-linear-recurrence family (linear attention, gated linear attention, SSD/Mamba-2, KDA, and gated DeltaNet) can be trained through one native tensor-core backward, verified against a double-precision oracle, rather than through separate implementations.
  • The same tensor-memory lifecycle error behind a known 38.7x slowdown is detectable by the verifier's resource gate, so future kernel-generation benchmarks can screen for it without waiting for an upstream compiler fix.
  • Because the verifier passed all seven independently verified kernels and caught a real defect in the authors' own kernel, its acceptances and rejections carry weight for judging both foreign and self-authored kernels.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper: if other public kernel-generation corpora share this acceptance signal, their reported speedups should be re-audited with tolerance-free contracts before being relied on in production or downstream training.
  • Beyond the paper: a benchmark standard that pays a speed bonus only after every contract passes could shift what language models optimize for, since the paper's edit-based reinforcement-learning attempt shows source-level exploration is the weak action space while launch-knob autotuning succeeds.
  • Beyond the paper: the verifier's tolerance-free gates could serve as a cheap runtime health monitor in training loops—surfacing swallowed NaNs early—rather than only as a post-hoc audit instrument.
  • Beyond the paper: the observed one-directional disagreement (1,487 to 14) is itself a diagnostic signature; a similarly asymmetric disagreement between a new checker and an established one elsewhere would indicate a systematic blind spot rather than stricter calibration.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper presents a twelve-gate 'contract-grade' verifier for GPU kernels, operationalizing a prior Kernel Contracts taxonomy, and uses it both to audit 2,638 kernels that the Dr. Kernel/KernelGYM corpus's own harness had accepted and to certify the authors' native Blackwell tcgen05 training backward for the GDN family. The audit reports 62.1% of accepted kernels with at least one contract violation and a tolerance-free floor of 39.5% (1,043/2,638), with a differential showing the standard KernelBench-style check certifying 1,487 kernels the verifier rejects and only 14 in the reverse direction. Four defenses are offered: a 7/7 positive control, a threshold-calibration sweep, 98.5% agreement with KernelBench's own correctness code, and a hand-audit of 31 disputed cases. The native backward is verified against an fp64 oracle with worst relative error about 3.3e-3 (with one disclosed 5.21e-3 arm), is deterministic, and trains five GDN-family variants, though it is slower than the fla Triton baseline. The paper also reports supporting results: six contract-verified Mamba-3 Triton kernels, a reproduction of the #904 TMEM bug, a 1.1B-parameter training demonstration, and a GRPO autotuning study with a negative edit-RL result.

Significance. If the audit's reference semantics is accepted, this is a substantial and carefully defended result. The paper does what the field's loose allclose checks cannot: it makes silent wrongness measurable, and the near-unidirectional disagreement (1,487 vs 14) is a strong signature of a systematic blind spot in the standard acceptance signal. The four defenses are genuinely falsifiable, the red team of nineteen broken kernels is a useful two-sided check, and the paper is unusually transparent about thin margins (ORD-03), idle gates (CMP-02/RES-02), the dv=128 accuracy overrun, and the native kernel's speed deficit. The native tcgen05 GDN backward is a credible systems contribution even without a speed win, and the fp64-oracle verification ladder with machine-exact tile spec-pins gives the correctness claim independent support. My reservation is that the headline 'broken beyond tolerance' floor rests on a normative choice of reference semantics (exact NaN/Inf propagation, non-FTZ subnormal handling, bitwise determinism) that the paper asserts rather than benchmarks; this should be fixed before the headline rates are published as facts.

major comments (4)
  1. [§3.1, Table 1, Figure 1] The tolerance-free floor of 39.5% (1,043/2,638) is carried by EXC-01 (34.2%), EXC-02 (9.3%), and ORD-02 (4.9%), whose pass criteria encode a normative reference semantics and not a mathematical fact. Section 3.1 defines the reference as 'a plain high-precision loop that is defined to be ground truth and refuses to execute in reduced precision,' and EXC-02 requires flush-to-zero handling to match that loop, while EXC-01 requires exact NaN/Inf positions and signs. On CUDA, FTZ is the default for single-precision operations and fast-math compilation legitimately changes NaN propagation, so a kernel written for that platform contract can be correct under its own semantics and still fail both gates. The four defenses in §3.3 show the verifier is internally consistent and not merely a stricter allclose, but none of them independently validates the chosen reference as the only legitimate correctness contract. The 'no tolerance can excuse' claim therefore requires either benchmarking the reference semantics against common CUDA compilation modes (e.g., an FTZ/fast-math variant of the reference) or explicitly scoping the headline floor to the paper's contract rather than to correctness simpliciter.
  2. [§3.1, ORD-02 row, Table 4] ORD-02's byte-for-byte determinism requirement is likewise a normative contract, not a tolerance-free mathematical property. A reduction using atomics may produce run-to-run results that differ by small rounding amounts yet lie well within every meaningful acceptance tolerance; labeling such a kernel 'broken beyond any tolerance argument' presupposes determinism as a universal requirement. The 126 kernels failing ORD-02 (4.9%) are included in the 1,043 floor, so the floor's interpretation depends on this presupposition as well. The paper should either justify determinism as a correctness contract for all audited systems or move ORD-02 out of the tolerance-free floor.
  3. [§3.3(4), Section 3.2] The hand-audit of 31 disputed cases classifies 7 as out of scope and says they are 'dropped from the strict floor,' yet the headline floor of 1,043 is reported in Section 3.2 as the automated gate count. The paper should clarify whether those 7 were excluded from the 1,043 and, if so, how the floor was recomputed for the entire corpus; if they were not excluded, the sentence is misleading. More generally, the hand-audit's 16/31 genuine-broken rate is not shown to extrapolate to the load-bearing cell, so the defense does not by itself confirm the 39.5% floor.
  4. [§3.3(3)] The claim that 'the benchmark's own harness agrees (98.5%)' is reported over 1,030 pairs, but the accepted corpus has 2,638 kernels. Please specify how those 1,030 pairs were selected and, if they are a sample, demonstrate representativeness with respect to operator class, gate outcomes, and the load-bearing cell. Without this, the otherwise valuable check that the replica matches KernelBench's own code cannot be extended to the full differential of §3.4.
minor comments (4)
  1. [Abstract, Section 1] The abstract and Section 1 state the 39.5% floor as 'broken beyond any tolerance argument' before Section 3.1 defines the normative reference semantics; consider adding a one-sentence caveat at first use so readers do not over-read the floor.
  2. [§3.3(1)] The phrase 'thesamebattery in thesameModel/ModelNewconvention' is missing spaces; the manuscript has several similar spacing typos that should be corrected.
  3. [§3.5] The 'pre-registered kill criterion' is mentioned without a pre-registration timestamp or document identifier; if it was pre-registered, cite it, otherwise use 'prespecified'.
  4. [Appendix B, Table 5] The note that printed margins are not exactly reproducible from printed values because of unrounded measurements is likely to confuse; round the threshold and onset columns consistently or include the unrounded values in the supplement.

Circularity Check

1 steps flagged · score 2.0 of 10

Mild circularity in the positive-control defense; the core audit and native-kernel verification are externally anchored.

  1. fitted input called prediction [Section 3.3(1) 'Positive control: 7/7', combined with Appendix C.1]
    "The verifier’s tolerance model was calibrated against those six Triton kernels, whereas the native GDN backward played no part in calibration, so it is a control the thresholds were never fitted to."

    Six of the seven positive-control kernels are the same kernels used to calibrate the band-gate thresholds (Appendix C.1: 'These six fixed the thresholds; the positive control tests the verdicts'). Their clean pass is therefore partly guaranteed by construction, since the thresholds were placed, by the authors' own account, at 'the loosest point that still sides with the candidate' relative to those known-correct kernels. The paper discloses this and supplements it with a held-out native GDN backward, tolerance-free gates that carry no thresholds, 98.5% agreement with KernelBench's own code, and a stratified hand-audit, so this circularity is contained to one fairness defense and does not drive the 39.5% tolerance-free floor.

full rationale

The paper's central quantitative claims are not derived from their own outputs. The 39.5% tolerance-free floor is a count of kernels that fail gates comparing exact NaN/Inf position and FTZ behavior to a high-precision reference; the reference semantics are stipulated (Section 3.1: 'defined to be ground truth') and the paper states the corresponding limitation ('Reference correctness: the audit is only as good as its references'). That is a normative contract choice, not an equation-level circular reduction, and the finding is additionally checked against KernelBench's own code (98.5% agreement), a stratified hand-audit, and a second stack/corpus. The native GDN backward is verified against a token-serial fp64 oracle and closed-form spec pins, with one disclosed out-of-envelope arm, so its correctness does not depend on the verifier's verdicts. The only concrete circular element is the positive control: six of the seven kernels in the 7/7 control are the same kernels used to calibrate the thresholded gates, so their passing is partly forced by the fit. The authors disclose this, and the held-out native kernel, threshold-free tolerance-free gates, and external defenses keep the central claims independently grounded. There is no load-bearing self-citation chain and no imported uniqueness theorem.

Assumptions & free parameters 2 free parameters · 6 assumptions · 0 invented entities

The central audit numbers rest on domain assumptions about reference correctness and IEEE semantics, plus hand-calibrated tolerance thresholds; the native kernel rests on an fp64 oracle and a hand-set 5e-3 bound. No invented physical or mathematical entities are introduced.

free parameters (2)
  • Band-gate tolerance thresholds = CMP-01 and CMP-03: 4.2e-5; ORD-01: 3.2e-5; ORD-03: 1.0e-3; PRC-02: 3.5e-2 at N=2048
    Calibrated against the authors' six known-correct Mamba-3 Triton kernels and set to the stated loosest defensible point, per Sections 3.1 and 3.3 and Appendix C.1.
  • GDN backward acceptance bound = 5e-3 worst relative error vs fp64 oracle
    Hand-set acceptance threshold for the native kernel's correctness claim; Section 4.5.
assumptions (6)
  • domain assumption High-precision reference loops define ground truth for every audited operator, including NaN/Inf and subnormal behavior.
    The verifier grades all candidates against these references (Section 3.1); if a reference mis-specifies valid numeric behavior, the failure rates are wrong.
  • domain assumption Exact non-finite propagation and flush-to-zero behavior are mandatory properties of a correct kernel.
    EXC-01 and EXC-02 are tolerance-free gates; this normative choice drives the 39.5% floor (Table 1 and Section 3.1).
  • domain assumption The floating-point error accumulation model atol approximately 4 epsilon sqrt(N) times scale describes the correct kernel's noise and the wrong kernel's error separation.
    ORD-01 uses this model to define its threshold (Section 3.1); it is derived from rounding error theory but the constant and scaling are assumptions.
  • domain assumption The Dr. Kernel corpus's 'accepted as correct' status is faithfully encoded by final_speedup greater than 0.
    The audit denominator is the accepted set; this predicate is asserted to record the harness's correctness verdict (Section 3.2).
  • standard math The GDN recurrence in Equation (1) is a superset that recovers LA, GLA, SSD, KDA, and GDN under the stated gate settings.
    Table 2 states the reductions; the authors say each member is verified against its own reference rather than by setting knobs on the GDN path.
  • standard math WY and triangular-inverse VJP can reuse the forward's T as two triangular multiplies without re-inversion.
    Section 4.2; standard matrix identity for the delta rule backward.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Contract-Grade Verifier for LLM-Generated GPU Kernels, and a Native Blackwell Backward for the Gated-Linear-Recurrence Family." pith.science (2026). https://pith.science/paper/W7LMGYRI

@misc{pith2026260812700,
  author       = {Pith},
  title        = {Pith review of: A Contract-Grade Verifier for LLM-Generated GPU Kernels, and a Native Blackwell Backward for the Gated-Linear-Recurrence Family},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/W7LMGYRI}},
  note         = {Machine review of arXiv:2608.12700}
}
read the original abstract

Systems that generate GPU kernels with language models report high correctness rates. Those rates come from a single loose test: run the kernel on a few random inputs at one fixed shape and accept it if the output is close to a reference. A kernel can pass that test and still be silently wrong. It can return an ordinary number where the true answer is a NaN or an infinity, differ from run to run, break when the shape changes, or accumulate in fp16 where the reference keeps an fp32 total. We build the instrument that checks correctness properly: a contract-grade verifier of twelve adversarial gates, each a property a correct kernel must satisfy, several of them tolerance-free, so no choice of threshold can explain a failure away. Aimed outward, the verifier audits 2,638 machine-generated kernels that a public system's own harness had already accepted as correct. It finds 39.5% broken beyond any tolerance argument and 62.1% carrying at least one violation. The field's standard test accepts 1,487 kernels the verifier rejects, against only 14 the other way. We defend the finding four independent ways: a 7/7 positive control, a threshold-calibration sweep, 98.5% agreement with the reference benchmark's own correctness code, and a stratified hand-audit. Aimed inward, the verifier judges a kernel of our own: the first native Blackwell tcgen05 training backward for the gated-linear-recurrence (GDN) family, including the reverse-state stage the field still runs on a fallback. We establish its correctness independently, against a double-precision oracle, and train five family members through it. The correctness signal behind reported progress in kernel generation is far weaker than the numbers suggest, and a set of tolerance-free contracts would close most of the gap.

Figures

Figures reproduced from arXiv: 2608.12700 by the authors.

Figure 1
Figure 1. The rigor-gap finding. Top: of the 2,638 kernels a public system’s own harness accepted as correct, 62.1% carry at least one contract violation and 39.5% (1,043) fail a tolerance-free gate, the floor no tolerance argument can reach. Bottom: per-gate failure rate among the kernels where each gate applies (tolerance-free gates in solid black). The modal defect, EXC-01 non-finite non-propagation, is the failure mode th… view at source ↗
Figure 2
Figure 2. Threshold calibration. For each band-gate, the chosen threshold (bar) sits inside the safe margin between the noise a correct kernel emits (circle, left) and the error a wrong one emits (cross, right), on a log scale of relative deviation from the reference. The thresholds are neither too tight, so a correct kernel is never flagged, nor too loose, so a wrong one is always caught. ORD-03’s upper margin is disclosed a… view at source ↗
Figure 3
Figure 3. The differential, a 2 × 2 contingency table with each cell shaded by its count. KernelBench’s own paper-era check accepts 93.7% of these kernels; the load-bearing cell (accepted by the benchmark, rejected by us) holds 1,487 kernels, 958 of them on a tolerance-free gate, while only 14 go the other way. The near-unidirectional disagreement is the signature of a systematic blind spot in the acceptance signal, not of tw… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

18 extracted references · 6 canonical work pages

  1. [1]

    Transformers are SSMs: Generalized models and efficient algorithms throughstructuredstatespaceduality

    Tri Dao and Albert Gu. Transformers are SSMs: Generalized models and efficient algorithms throughstructuredstatespaceduality. InInternationalConferenceonMachineLearning(ICML),

    work page

  2. [2]

    Dataset: hkust-nlp/drkernel-coldstart-8k

    Dr.Kernel(KernelGYM)Authors.Dr.Kernel(KernelGYM):Acold-startcorpusforTritonkernel generation.arXiv preprint arXiv:2602.05885, 2026. Dataset: hkust-nlp/drkernel-coldstart-8k

    arXiv 2026

  3. [3]

    Mamba: Linear-time sequence modeling with selective state spaces

    Albert Gu and Tri Dao. Mamba: Linear-time sequence modeling with selective state spaces. arXiv preprint arXiv:2312.00752, 2023

    arXiv 2023

  4. [4]

    Lange et al

    R. Lange et al. The AI CUDA engineer and robust kernel benchmarking.arXiv preprint arXiv:2509.14279, 2025

    arXiv 2025

  5. [5]

    Li et al

    J. Li et al. TritonBench: Benchmarking large language model capabilities for generating Triton operators.arXiv preprint arXiv:2502.14752, 2025

    arXiv 2025

  6. [6]

    Li et al

    X. Li et al. CUDA-L1: Reinforcement learning for CUDA kernel optimization.arXiv preprint arXiv:2507.14111, 2025

    arXiv 2025

  7. [7]

    Mamba-3: Structured state-space models with complex and multi-input- multi-output recurrences.International Conference on Learning Representations (ICLR); arXiv:2603.15569, 2026

    Mamba-3 Authors. Mamba-3: Structured state-space models with complex and multi-input- multi-output recurrences.International Conference on Learning Representations (ICLR); arXiv:2603.15569, 2026. OpenReview id HwCvaJOiCj

    arXiv 2026

  8. [8]

    Ouyang et al

    A. Ouyang et al. KernelBench: Can LLMs write efficient GPU kernels?arXiv preprint arXiv:2502.10517, 2025

    arXiv 2025

Show all 18 references
  1. [9]

    A. Sarkar. The correctness illusion in LLM-generated GPU kernels.arXiv preprint arXiv:2606.20128, 2026

    2026 arXiv

  2. [10]

    DeepSeekMath: Pushing the limits of mathematical reasoning in open language models.arXiv preprint arXiv:2402.03300, 2024

    Zhihong Shao et al. DeepSeekMath: Pushing the limits of mathematical reasoning in open language models.arXiv preprint arXiv:2402.03300, 2024. Introduces Group Relative Policy Optimization (GRPO)

    2024 arXiv

  3. [11]

    Issue #904: Mamba-3 SISO backward is 38.7× slower on GB200/B200

    state-spaces/mamba contributors. Issue #904: Mamba-3 SISO backward is 38.7× slower on GB200/B200. https://github.com/state-spaces/mamba/issues/904 , 2026. Open; companion Triton PR #9093 (merged)

    2026

  4. [12]

    T. Veit. Kernel contracts: A taxonomy of correctness classes for gpu kernels.arXiv preprint arXiv:2604.22032, 2026

    2026 arXiv

  5. [13]

    Lunze, Wojciech Samek, and Tobias Schaeffter

    Patrick Wagner, Nils Strodthoff, Ralf-Dieter Bousseljot, Dieter Kreiseler, Fatima I. Lunze, Wojciech Samek, and Tobias Schaeffter. PTB-XL, a large publicly available electrocardiography dataset.Scientific Data, 7(1):154, 2020

    2020

  6. [14]

    Gated delta networks: Improving mamba2 with delta rule

    Songlin Yang, Jan Kautz, and Ali Hatamizadeh. Gated delta networks: Improving mamba2 with delta rule. InInternational Conference on Learning Representations (ICLR), 2025. arXiv:2412.06464

    2025 arXiv

  7. [15]

    Gated linear attention transformers with hardware-efficient training

    Songlin Yang, Bailin Wang, Yikang Shen, Rameswar Panda, and Yoon Kim. Gated linear attention transformers with hardware-efficient training. InInternational Conference on Machine Learning (ICML), 2024. arXiv:2312.06635

    2024 arXiv

  8. [16]

    Parallelizing linear transformers with the delta rule over sequence length

    Songlin Yang, Bailin Wang, Yu Zhang, Yikang Shen, and Yoon Kim. Parallelizing linear transformers with the delta rule over sequence length. InAdvances in Neural Information Processing Systems (NeurIPS), 2024. arXiv:2406.06484

    2024 arXiv

  9. [17]

    FLA:Atriton-basedlibraryforhardware-efficientimplementations of linear attention mechanisms.https://github.com/fla-org/flash-linear-attenti on, 2024

    SonglinYangandYuZhang. FLA:Atriton-basedlibraryforhardware-efficientimplementations of linear attention mechanisms.https://github.com/fla-org/flash-linear-attenti on, 2024. 16

    2024

  10. [18]

    Zhong et al

    Y. Zhong et al. Hardening agent benchmarks against reward hacking.arXiv preprint arXiv:2606.08960, 2026. 17

    2026 arXiv

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.