Skip to content
Verification engine · the moat

Anyone can claim a speedup.
Kernalin proves it.

A faster number means nothing if the model quietly got worse. Every optimization runs a gauntlet no fake survives — kept only if it's correct, honest, and genuinely faster, and thrown out before you ever see it otherwise. This is the whole company, and the part investors diligence hardest.

Request early access Explore the platform
The gauntlet

Seven checks. One verdict.

Scroll to watch each stage activate. A candidate that fails any of them never reaches a verified speedup.
Candidates in
0
every rewrite the AI proposes
Rejected by the gauntlet
0
wrong, cheating, or within noise
Verified out
0
the only one you'd ship

Illustrative counts. In our H100 run, 1 of 4 Claude rewrites was kept; 3 were correct but not faster.

The gauntlet · 7 checks, in order idle
  1. 01

    Smoke test

    queued

    Does the candidate run and produce output at all?

  2. 02

    Shape sweep

    queued

    Tall, wide, deep-K, vocab, and LLM shapes — not just the demo case.

  3. 03

    Adversarial inputs

    queued

    Distribution-matched fuzzing and input transforms.

  4. 04

    Determinism

    queued

    Bitwise-identical output across repeated runs.

  5. 05

    Edge cases

    queued

    Non-power-of-two and boundary shapes (1023, 4097, 50257).

  6. 06

    Anti-cheat

    queued

    Input-differential + op-coverage: no dropped ops, no ignored inputs.

  7. 07

    Statistical benchmark

    queued

    Bayesian ROPE verdict over a bootstrap posterior vs. the noise floor.

Verified speedup

Correct · not gaming the benchmark · genuinely faster

1.91ms
−32.7% vs baseline

One number ships only if it's correct, honest, and genuinely faster. Everything else is stopped before it ever reaches you.

Correctness first

Timing never happens before correctness.

Before a candidate is measured, it runs a five-stage correctness gate: a smoke test, a shape sweep across tall / wide / deep-K / vocab / LLM shapes, adversarial input transforms, bitwise determinism, and non-power-of-two edge cases (1023, 4097, 50257). Fail any stage and the change is reverted before a stopwatch ever starts.
1 Smoke test gate
2 Shape sweep gate
3 Adversarial inputs gate
4 Determinism (bitwise) gate
5 Edge cases gate
The blind spot

A broken kernel can be provably wrong — and still pass.

Testing on a representative case is not enough, and this is why. At the demo case, whole classes of bugs are structurally invisible — not unlikely, impossible to see. Watch a single probe wave the bug through while Kernalin's megakernel verifier (research preview) refutes it.
kernalin · blind-spot demo auto
Kernel under test ATTENTION_TILE flash_attn_fwd.cu

Injected bug: max never subtracted from the exponent

A single demo-case probe

how most tools check
PASS
output matches on the demo case

With kv_len = 1, softmax over one element is exactly 1.0 — the output is v₀ regardless of the entire score path.

Kernalin · structural verification

how we check
REFUTED
ptx-symbolic · bounded-recurrence

A structural check sees the missing subtraction immediately — it doesn't need an input that happens to trigger the overflow.

Demo probe passes
0 / 14 bugs
Kernalin refutes
14 / 14 bugs

The sharpest case: a stray write to pos+1 in the KV cache self-heals — the next decode step overwrites the damage — so it surfaces only at the final token, or in another head, far from the cause. A structural write-footprint check sees it at once. Every ratio on this page comes from the engine's bug-class tables; of the 14 known-bad PTX fixtures that ship with it, all 14 are refuted, none passes.

Anti-cheat

Two independent ways to catch a reward-hack.

A kernel can be correct on the inputs you tried and still be gaming the benchmark. These two families close that gap — and they're independent, so a hack has to beat both.

Input-differential

Fresh, distribution-matched random inputs on every trial, poisoned output buffers, and tensor-provenance checks. Catches kernels that memorized the reference output or ignore their inputs.

Operation coverage

Executed FLOP/byte must meet an analytic lower bound, and every input region is perturbed to confirm the output responds. Catches kernels that "optimized" by dropping an operation.

Reward-hacks Kernalin refuses

Dropping operations the reference needs
Ignoring inputs and returning a constant
Memorizing the reference output
Special-casing the benchmark shape
Exploiting a cached result buffer
Statistically misleading timing
Statistically honest

A verdict, not a vibe.

Timing flushes L2, captures the kernel in a CUDA graph, and locks GPU clocks when the host permits it. Where it can't (most cloud pods), the run is labelled AS_DEPLOYED — measured without clock control — rather than passed off as a controlled number. The decision is a Bayesian ROPE verdict over a bootstrap posterior of the median-latency ratio, judged against your GPU's noise floor — credibly faster, equivalent, or regressed. Never a naive "1% faster" gate that noise can fake.
How benchmarking works
Credibly faster
Posterior mass convincingly beyond the noise floor.
Equivalent
Within the band where the hardware can’t tell the difference.
Regressed
Convincingly slower — blocked before it ships.
Formal verification · research preview

When it can't prove equivalence, it refuses.

Scope first: formal verification currently covers the instruction obligations of megakernels (AutoMegaKernel-style decode programs), checked against hand-written PTX. It does not yet run on the Triton, PyTorch or CUDA kernels you upload — those go through the correctness gate, anti-cheat and statistical verdict above. Within that scope, the formal layer does PTX-level symbolic equivalence over real arithmetic, runs a warp-SIMT interpreter for the shuffle reductions real megakernels use, and issues proof-carrying race-freedom certificates. The invariant is simple and strict: refuse rather than guess. Anything outside the modelled subset returns UNSUPPORTED — a verifier that skips an opcode would happily prove a kernel whose real work happened in the instruction it skipped.

Typical AI optimizer

Unproven
1 Generate
2 Benchmark
3 Ship "48% faster" could be wrong

A headline number with nothing behind it. If the kernel dropped an op, ignored an input, or memorized the reference output, you ship a bug at speed.

Kernalin

Verified
Generate
Correctness gate
Input-differential
Op-coverage
Statistical benchmark
Verified speedup deserves to exist

Every speedup survives correctness, anti-cheat, and statistical checks before it counts. The number you see is the number you can ship.

Proof-carrying

Don't trust the validator. Check the certificate.

A validator's "ok" is only as trustworthy as the validator. So Kernalin replaces the opinion with a certificate — an explicit happens-before witness for every read of a written buffer. A short, separate checker re-verifies it without redoing the analysis. That shrinks the trust base from "our graph analysis is correct" to "this short checker is correct." Certificates are digest-bound: a valid proof of a safe schedule can't be stapled onto a racy one.
check_certificate() race-freedom · V2

The checker re-verifies the proof without redoing the analysis. It demands a witness for every read of a written buffer — so a certificate cannot pass by omitting the read that races.

  1. 1
    write W₀ → read R₃
    happens-before via counter c1 join
  2. 2
    write W₁ → read R₇
    transitive: c1 ⇒ c4 ⇒ c4.threshold
  3. 3
    counter c4 join
    true-join rule: all 8 producers arrived
  4. 4
    read R₉ of buffer kv[pos]
    witness present · footprint bound
  5. 5
    digest 3f9a…c1 == program
    certificate bound to this artifact
Trust base
"our graph analysis is correct"
"this short checker is correct"
checking…
soundness = SCHEDULE_ONLY
race freedom proved · functional correctness by testing
Composition

Two premises become one honest verdict.

A race-freedom certificate and per-instruction equivalence compose into a single soundness level. The design invariant that matters most: REFUTED is checked before the schedule and dominates it. A race-free schedule of a proven-wrong instruction is still wrong. Try it — feed a buggy instruction to a perfect schedule and the verdict stays REFUTED.
prove_artifact() · compose soundness
Premise 1 · schedule
Premise 2 · instructions
FULL
Race-free schedule and every instruction proved equivalent — the megakernel computes the reference function over real arithmetic.
Silence is not proof — an obligation with no PTX stays PENDING, never rounds up to FULL.
run-log · build block 
{
  "backend":     "CUDA_CPP",
  "compiler":    "nvcc 12.4",
  "arch":        "sm_90a",
  "fast_math":   false,          // off unless asked
  "flags":       ["-O3", "--fmad=true"],
  "cache_key":   "b7c1…9f2",
  "compiled_in": "sandbox"       // same isolation as exec
}
Numerics integrity

The engine compiles the CUDA — not the candidate.

A Python candidate calling load_inline itself would pick its own flags, including --use_fast_math, which changes FTZ, division, square root, and every transcendental. A product whose claim is "this speedup is verified" cannot let the artifact under test choose numerics the engine never recorded. So flags, arch, and the cache key live in the engine, fast math is off unless asked for, and whatever was used is recorded in the run log. Compilation happens inside the sandbox — an untrusted candidate's nvcc invocation is untrusted code too.
The honest headline

We publish our own ceiling.

A truthful "formally verified" claim starts by reporting how far it is from a whole-program guarantee. So Kernalin measures coverage in three separate layers and refuses to quote the generous one.
Statable 100%

Ops with reference semantics — every op a real decode program runs has one.

Verifier-covered 100%

A checker exists for it. By task and by signature, after GEMV + the tail ops.

Reaches real device PTX gated

The last mile needs a GPU build (layer 3b). We say so, rather than round up.

The three high-risk ops were verified first for the moat (~2% of the work, but the blind spots); GEMV_TILE was built last for the moat and first for coverage — one verifier takes task coverage from 2.1% to 97%. Reporting that distance honestly is the number a real guarantee starts from.

Early access is open

Speedups you can trust.

Bring verification-first optimization to your GPU workloads. Join the early-access program.

Request early access Explore the platform