Agentic GPU work / proof order / 29 SEP 2026

Fast is the last reading.

A generated GPU kernel can compile, return zero, and post a good timing while still being wrong. Lock the workload, correctness, and test cell before touching the speed dial.

The new tool worth opening

The harness is part of the program

TIRx Harness is an open compiler environment for agent-written GPU kernels. It combines a small compiler foundation, hardware and kernel references, analysis tools, and a benchmark server. The project gives an agent more than a source file and a stopwatch.

The design matters because kernel tuning is a chain of decisions. A compiler can lower an idea differently than expected. A race can hide across ordinary test runs. Another job on the same GPU can move a timing. If the agent treats each result as ground truth, the next edit can optimize noise or preserve a bug.

The MLC team reports geometric-mean speedups between 1.33x and 6.84x across the workload families it evaluated. Those are project results on named workloads and hardware, not a general promise about generated kernels. The stronger lesson is in the test setup. The harness separates analysis, correctness policy, controlled execution, and retained candidates.

The kernel is one artifact. The workload contract, compiler path, test inputs, hardware, and measurement record decide what the artifact means.

01 / CONTRACT

Freeze the job

Name shapes, dtypes, tolerances, baseline, hardware, and the scoring rule before search begins.

02 / CORRECTNESS

Look past one pass

Run numerical checks and inspect synchronization and memory behavior that sample inputs may miss.

03 / TEST CELL

Control the clock

Keep candidates on the same GPU, inputs, warmup, load, compiler, and timing method.

04 / CANDIDATE

Keep the evidence

Save the exact source, result rows, timing, diagnostics, and reason the candidate survived.

Interactive makeover / kernel proof dyno

Build the test plan in proof order

A speed badge collapses several checks into one number. This native-checkbox dyno keeps the four records separate and only connects a contiguous proof route. It builds a review template. It does not run a kernel or attach benchmark evidence.

LOCK JOBCHECK RESULTCONTROL CELLRETAIN PROOF

Dyno interlocks

Select the records the test plan will request. A later record cannot repair an open earlier gate.

Include test records

Workload contractShapes, dtypes, tolerance, baseline, target GPU, and score.Selected Correctness recordExpected rows, numerical result, race checks, and diagnostics.Selected Test cell recordDevice, compiler, warmup, repetitions, load, and timing method.Open Candidate recordRevision, source, result table, speedup, and retention reason.Open

2 of 4 test records selectedProof route reaches correctness

Correctness is specified. Timing remains open.

The contract and correctness sections are selected. The plan still needs a controlled test cell and an exact retained candidate. No kernel result is attached.

KERNEL PROOF DYNO / TEST PLAN

[x] WORKLOAD_CONTRACT
SHAPES_AND_DTYPES=[REQUIRED]
TOLERANCE=[REQUIRED]
BASELINE=[REQUIRED]
TARGET_GPU=[REQUIRED]
SCORING_RULE=[REQUIRED]

[x] CORRECTNESS_RECORD
EXPECTED_ROWS=[REQUIRED]
NUMERICAL_RESULT=[REQUIRED]
RACE_AND_SYNC_CHECK=[REQUIRED]
DIAGNOSTICS=[REQUIRED]

[ ] TEST_CELL_RECORD
COMPILER_AND_FLAGS=[REQUIRED]
WARMUP_AND_REPETITIONS=[REQUIRED]
CONCURRENT_LOAD=[REQUIRED]
TIMING_METHOD=[REQUIRED]

[ ] CANDIDATE_RECORD
SOURCE_REVISION=[REQUIRED]
RESULT_ROWS=[REQUIRED]
MEASURED_SPEEDUP=[REQUIRED]
RETENTION_REASON=[REQUIRED]

STATUS=2 OF 4 TEST RECORDS SELECTED
KERNEL_RUN=NOT ATTACHED
PERFORMANCE_VERDICT=NOT AVAILABLE

What the speedometer misses

A clean command can carry a dirty result

The TIRx optimization guide warns that scoring commands can exit with status zero even when workloads fail. It tells operators to inspect every expected row for PASS before accepting a candidate. That warning belongs in any agent loop. Process success, numerical correctness, and performance are different readings.

The project also describes a candidate that passed ordinary correctness tests while its synchronization analysis found a latent barrier bug. The issue depended on timing. More test repetitions alone would not explain it. The analysis gave the agent a concrete synchronization failure to repair.

KernelBench supplies useful scale. Its authors evaluated generated kernels on 250 PyTorch workloads. Their 2025 paper reported that frontier reasoning models matched the PyTorch baseline in fewer than 20 percent of cases without iterative execution and profiling feedback. A stronger model helped, but the evaluation loop still decided whether an output was both correct and faster.

Put the order into the interface. Lock the task. Check the result. Control the test cell. Retain the candidate and its evidence. Read speed last.

Source log / read 29 SEP 2026

What was read and what was checked

MLC TIRx Harness announcementHarness design, controlled remote evaluation, reported workload results, and the synchronization defect found after ordinary tests passed.blog.mlc.ai/2026/09/29/tirx-harness-an-open-compiler-harness-for-agentic-gpu-programming TIRx Harness repositoryPublic source, package name, TIRx-lite language, analysis tools, remote execution component, skills, and workload contracts.github.com/mlc-ai/TIRx-harness TIRx optimization run guideSetup, fixed workload policy, frontier records, candidate replay, result-row inspection, and the warning that a zero exit can still contain failed workloads.tirxharness.mlc.ai/docs/optimization-runs.html KernelBench paperA 250-workload benchmark for fast and correct generated GPU kernels, plus the reported gap between raw model output and the PyTorch baseline.arxiv.org/abs/2502.10517 NVIDIA PTX ISA documentationThe instruction-set reference that the TIRx project names as its source for low-level instruction semantics.docs.nvidia.com/cuda/parallel-thread-execution/ PyPI package recordVersion 0.1.2, Python 3.12 through 3.13 requirement, published Linux wheels, source archive, and project links.pypi.org/project/tirx-harness/

Artifact check: PyPI returned version 0.1.2. The Linux x86-64 wheel downloaded successfully, contained 189 files, and matched PyPI's SHA-256 digest 271360b99a8a23d2a54389fc3d26df2b5966164305aaa049baa7681e109d28c2. This host has Python 3.11 and no compatible GPU test cell, so the package and kernel workflow were not executed.