Alexsssu/fastkernels-b200-codex-vanilla-20260923

Vanilla Codex on FastKernels: independent vs. compositional kernel generation

A single codex exec session per operator, over all 133 L1-L3 operators of the FastKernels default B200 capture, run twice: once with every operator optimised independently, and once with L2/L3 regenerated on top of the frozen winning kernels of the levels below. 1.4 billion tokens, 8x B200, one day.

What this run adds

FastKernels argues for its L1-L4 compositional hierarchy as a design pillar -- an agent should be able to reuse an optimised lower-level kernel "instead of rediscovering the same building block from scratch". Its published agent evaluation covers L1 and L2 only, with every operator optimised independently, so the pillar is argued rather than measured. This run measures it: the same 133 operators, generated under both regimes, both winner sets benchmarked composed.

1. Composition is a correctness mechanism, not just an efficiency one. Independently generated kernels pass 576 of 582 scenarios when measured one at a time. Load the winners together and 39 scenarios across 22 targets break. Under the compositional regime every one of the 507 scenarios passes, and on the 18 targets where the two regimes can be paired directly, all 18 go from failing to clean (Tables 1 and 2). The cost is 16-19% of the L2+L3 speedup. That is a sharper claim than the hierarchy's original framing: reuse is not mainly how the agent goes faster, it is how the output assembles at all.

2. The effect is attributable, not drift. The harness records whether an L2/L3 target imports a lower-level operator. Targets that import nothing cannot be reached by freezing the levels below them, and they come out at 0.9881x -- no effect -- while importers land at 0.7816x (Table 3).

3. All three misalignments named in the FastKernels abstract appear in one run, from an agent that was not trying to provoke any of them. Interface and contract violations: the 26 runtime errors of Table 2. Compilation-stack conflicts: three distinct TorchDynamo and Inductor failures, none of which is visible at the kernel level because every one of those candidates passed its bench. Silent correctness degradation: a MoE kernel that is 18-62x faster with 1-2% relative error and passes the tolerance checker, and greedy token agreement that falls to 249/1000 requests where a baseline-vs-baseline control holds at 1000/1000.

A fourth observation is about the benchmark rather than the agent: three executions of the identical scoring pipeline over the identical candidate files disagreed on the gate outcome of 11 of 133 targets, and the reward-hacking detector fired on three different targets across those three executions without ever repeating. See CANONICAL.md.

2026-09-23, alexsu-dev-b200-0. Runtime stack, code commits, agent configuration and the one harness change are in MANIFEST.md. Which scoring execution is authoritative is in CANONICAL.md. Every table is regenerated from results/ by make_tables.py, which also emits one table not shown here (Table 10, macro-geometric speedup by level).

Results

Table 1 -- headline

gated counts targets whose kernel passed every scenario and reached geomean >= 1.0x. composed correct is scenario-level, measured with all gated winners loaded together. Speedups are macro-geometric over targets. paired is the per-target sequential/independent ratio over the 60 L2+L3 targets both treatments gated.

treatment	gated	composed correct	L1	L2	L3	all levels	paired vs. independent
independent	114/133	410/451	1.780x	3.247x	5.594x	2.709x	--
sequential	119/124	507/507	1.747x	2.503x	2.563x	2.240x	0.806x

Table 2 -- matched-target correctness

The two composed benches cover different target sets (114 vs 119), so the 410/451 and 507/507 of Table 1 do not share a denominator. This table removes that objection by pairing targets.

level	target	independent, composed	sequential, composed
L2	alphafold3_attention_pair_bias	1x SKIPPED	4/4
L2	alphafold3_of3_attention	1x SKIPPED	5/5
L2	fused_experts	1x RUNTIME_ERROR	5/5
L2	kimi_delta_attention	1x RUNTIME_ERROR	5/5
L2	kimi_mla_attention	4x INCORRECT_NUMERICAL	5/5
L2	oasis_vae_attention	2x RUNTIME_ERROR	2/2
L2	qwen3_next_attention	1x RUNTIME_ERROR	5/5
L2	vision_patch_merger	1x INCORRECT_NUMERICAL	5/5
L3	alphafold3_diffusion_transformer	1x INCORRECT_NUMERICAL	3/3
L3	flux_transformer_block	4x INCORRECT_NUMERICAL	4/4
L3	gpt_oss_decoder	5x RUNTIME_ERROR	5/5
L3	kimi_linear_decoder	1x RUNTIME_ERROR	5/5
L3	llama_decoder	2x INCORRECT_NUMERICAL	5/5
L3	oasis_dit	5x RUNTIME_ERROR	5/5
L3	oasis_vae_attention_block	2x RUNTIME_ERROR	2/2
L3	qwen3_moe_decoder	1x RUNTIME_ERROR	5/5
L3	qwen3_next_decoder	1x RUNTIME_ERROR	5/5
L3	yolov10_neck	2x RUNTIME_ERROR	2/2

22 independent-composed targets have at least one failing scenario. 18 of them also exist in the sequential winner set and are listed above; all 18 pass every scenario there. The remaining 4 (alphafold3_atom_attention, kimi_moe, qwen3_moe, alphafold3_diffusion_module) were not gated into the sequential set, so there is nothing to compare them to.

Table 3 -- the effect is specific to composition, not a global drift

importer marks an L2/L3 target whose implementation imports a lower-level operator, i.e. the ones the frozen-winner treatment can actually reach. Non-importers are the built-in control.

subset	n	independent	sequential	paired seq/ind
importers	52	3.5628x	2.7845x	0.7816x
non-importers	8	3.2465x	3.2078x	0.9881x
all	60	3.5189x	2.8375x	0.8064x

Table 4 -- what the agent is measured against decides the result

The split is hand-curated (see VENDOR_BACKED in this script) and therefore approximate; it reproduces the qualitative split the FastKernels paper reports for Codex.

baseline type	targets	macro geomean	below 1.0x
vendor / hand-written (FlashAttention, FlashInfer, cuBLAS-class, custom all-reduce)	15	0.992x	9
other LLM-path	51	1.573x	4
non-LLM, plain-PyTorch reference	45	3.871x	1

Table 5 -- against the published Codex numbers

Paper figures are Codex on the 88-target configuration (arXiv:2605.23215, Table 1). The aggregate rows are not comparable -- see Table 4 -- but the vendor-backed subset is.

	paper (Codex)	this run (independent, standalone)
L1	1.035x (n=48)	1.543x (n=47)
L2	0.844x (n=40)	2.698x (n=64)
L1+L2	0.943x (n=88)	2.129x (n=111)
vendor-backed subset	0.930x (n=26)	0.992x (n=15)

Table 6 -- cost

session time is the sum of per-target session durations and includes time spent waiting for one of the 12 concurrent slots, so it is roughly an order of magnitude above wall-clock. Wall-clock was about 5.5 h for the independent half and about 3.5 h for the sequential half on one idle 8xB200 node.

half	targets	session time	codex tokens	tokens / target
independent	133	329 h	967,227,673	7,272,388
sequential	86	71 h	437,322,500	5,085,145

Read Tables 1 and 2 together. The independent regime is faster at every level and loses 39 scenarios the moment its kernels have to coexist; the compositional regime gives up 19% of the L2+L3 speedup and loses nothing. Table 2 exists because the two composed benches cover different target sets (114 vs 119), so the 410/451 and 507/507 of Table 1 do not share a denominator -- pairing the targets removes that objection and the result survives it.

Table 4 is the reason no single aggregate number describes this agent. Against FlashAttention, FlashInfer, cuBLAS-class GEMMs and the custom all-reduce it is at parity at best; against operators nobody has written a specialised kernel for it averages 3.871x. Table 5 shows the consequence: this run's aggregate is far above the published Codex figure, and the published figure is reproduced closely once the comparison is restricted to vendor-backed targets.

What is in this repository

The full report follows below; it is also in REPORT.md, which is the file this card is generated from.

path	what it is
REPORT.md	the analysis, identical to the text below
CANONICAL.md	which of three scoring executions is authoritative, how they disagree, and where the artifacts are not self-consistent
MANIFEST.md	node, runtime stack, code commits, agent configuration, harness settings, the one local change
SOURCE_NOTES.md	working documents that were deliberately not shipped, and why
results/ind/	standalone bench over all 133 merged candidates, the winner selection, per-target agent metrics
results/comp/	composed bench over the independent winners
results/seq/	composed bench over the sequential winners, plus per-level mix benches and gating decisions
results/compare.json	the harness's own independent-vs-sequential comparison
control/	fastkernels eval --self-test on Llama-3.1-8B, the baseline-vs-baseline control
patches/	the one harness change, the codex configuration for Snowflake Cortex, the scenario tables and driver scripts
logs/	the three driver logs
logs-agents.tar.gz	219 per-target codex session logs
make_tables.py, make_card.py	regenerate the tables from results/, and this card from REPORT.md

Every number below comes from results/. make_tables.py regenerates all seven tables; if it and the report disagree, the script is right and the report has a bug -- please open a discussion.

What was run

One codex exec session per operator, from the stock vanilla-agents-fastkernels harness against an unmodified FastKernels checkout. No RLCR loop, no kernel wiki, no reviewer, no master agent: the session gets the baseline, the captured shapes, a validate.py, and the CLI's own tools. This is the vanilla-agent leg.

Every one of the 133 L1-L3 operators in the default B200 capture was generated twice, under two treatments:

• independent -- each operator optimised on its own, with imports resolving to baselines.
• sequential -- L2 and L3 regenerated with the frozen winning kernels of the levels below already in place, so an agent optimising a decoder layer sees the optimised norms and attention it will actually call.

A kernel is a winner only if every non-skipped scenario passes the tolerance checker and its geometric-mean speedup is at least 1.0x. The two winner sets are then benchmarked composed, and compared. Total cost: 1.4 billion codex tokens over roughly 9 hours of wall clock.

Composition buys correctness and costs speed

Where the 39 failures of Tables 1 and 2 come from, scenario by scenario.

Table 7 -- scenario outcomes per bench pass

bench pass	scenarios	passed	failed	skipped
independent, standalone	582	576	5	1
independent, composed	451	410	39	2
sequential, composed	507	507	0	0

Independently generated kernels pass almost everything when measured one at a time (576/582). Assemble the winners into one stack and 39 scenarios break -- 26 with a RUNTIME_ERROR, 13 numerically. Generate the same operators with the lower levels frozen instead, and all 507 scenarios pass.

The failures are concentrated where composition actually happens: whole L3 blocks (gpt_oss_decoder, oasis_dit, llama_decoder, flux_transformer_block) and the L2 attention and MoE modules underneath them (kimi_mla_attention, fused_experts, kimi_moe, oasis_vae_attention). Each of these kernels satisfies its own interface in isolation. What they violate is the contract with the code around them.

The 0.806x of Table 1 is not driven by the one kernel that games the tolerance checker (see below); dropping it moves the ratio only to 0.843x.

Table 8 -- sequential vs independent with and without the tolerance escape

target set	n	independent	sequential	paired seq/ind
all shared L2+L3	60	3.519x	2.838x	0.806x
excluding tolerance escapes	59	3.407x	2.873x	0.843x

Why would being handed optimised building blocks make the result slower? The independent agent is free to rewrite a decoder layer as one monolithic fused kernel and often does. The sequential agent inherits components it is expected to call, and optimises around them. The first strategy produces the faster number and the stack that does not assemble; the second produces a slower number and a stack that does. That trade is the result.

Where a vanilla agent wins, and where it does not

Table 4 splits the speedup by baseline type. The gate's rejection list says the same thing in a different way -- it is almost a list of production hot paths.

Table 9 -- rejected targets

level	target	reason
L1	flash_attn_varlen	geomean 0.5787 < 1.0
L1	flash_attn_prefill	geomean 0.7819 < 1.0
L1	linear	geomean 0.7825 < 1.0
L1	flashinfer_prefill	geomean 0.8381 < 1.0
L1	gate_linear	geomean 0.8661 < 1.0
L1	fp8_linear	geomean 0.9205 < 1.0
L1	rms_norm	geomean 0.9245 < 1.0
L1	flashinfer_decode	geomean 0.9495 < 1.0
L1	bmm	geomean 0.9817 < 1.0
L2	gla_mlp	geomean 0.8442 < 1.0
L2	encoder_mlp	geomean 0.8597 < 1.0
L2	trtllm_mxfp4_moe	geomean 0.9120 < 1.0
L2	oasis_mlp	geomean 0.9975 < 1.0
L2	llama_mlp	geomean 0.9998 < 1.0
L2	shared_expert_moe	status INCORRECT_NUMERICAL
L3	alphafold3_pairformer	status REWARD_HACK
L3	gla_decoder	status INCORRECT_NUMERICAL
L3	oasis_rollout	no passed timed scenarios
L3	yolov10_backbone	status REWARD_HACK

The prompt forbids calling a finished vendor kernel as the implementation, so these are hand-written attempts at the hardest targets in the suite, and they lose.

One kernel that is fast because it is wrong

gpt_oss_moe is the single target where the two treatments disagree by more than an order of magnitude, and the reason is not optimisation.

treatment	speedup	max relative error
independent	17x - 62x	0.009 - 0.018
sequential	1.0x - 1.65x	0.0

The independent kernel is 18-62x faster with a 1-2% relative error; the sequential one is exact and modest. Both pass the checker, because the tolerance band for this operator is wide enough to admit the first. It is not stably inside the band either: an earlier scoring execution marked it INCORRECT_NUMERICAL with one shape returning all zeros (CANONICAL.md).

Scanning all 60 shared L2+L3 targets for the same signature -- independent inexact and much faster, sequential exact -- finds exactly one, this one. Removing it moves the headline from 0.806x to 0.843x, so the conclusion does not rest on it. But a tolerance-based checker admitted a 60x MoE kernel that does not compute the right thing, and a sweep reporting only aggregates would have reported that 60x.

End to end: three compilation-stack conflicts

fastkernels eval default produced no usable numbers for either treatment. Ten of eleven scenarios failed; only gla-2.7B passed, and it wrote no report. The failures are not all the agent's fault, and separating them matters:

cause	scenarios
candidate-induced compilation-stack conflict	Llama-3.1-8B, gpt-oss-120b, Kimi-Linear-48B, Qwen3-VL-235B (independent)
harness cannot build a tokenizer for a non-text model	FLUX.1-dev, yolov10n, OpenFold3, oasis-500m
harness calls load_dataset without a config name	bge-m3
gloo TCP rendezvous failure	Qwen3-Next-80B
harness holds both engines on GPU at tp>1	Qwen3-VL-235B (sequential)

Only the first row is about the generated kernels, and it is the interesting one. Three distinct Dynamo failures, all from candidates wrapping vendor code in a compiled region:

1. logging.Logger method not supported for non-export cases -- the candidate L2/attention_impl.py compiles a region that reaches FlashInfer's JIT cubin loader, which logs.
2. Dynamo does not know how to trace builtin operator 'open' -- the next statement in the same loader, reached after suppressing (1). Patching individual builtins is whack-a-mole; the structural problem is that a vendor JIT loader is inside the traced region at all.
3. In the deterministic mode of Inductor, we will avoid those benchmarkings that would cause non deterministic results -- a different candidate's own autotuning trips Inductor's determinism guard during CUDA-graph capture.

None of these are numerical errors and none would be visible at the kernel level: every one of these candidates passed its bench. They appear only when the kernel meets the compilation stack of a real model. That is the misalignment FastKernels was built to expose, reproduced here by an agent that was never trying to cause it.

The workaround for (1) is shipped as patches/dynamo-sitecustomize.py and is not applied to any number in this report. It is deliberately left off: making Dynamo tolerate the candidate's choices would hide the finding.

The control

Because the greedy-token comparison is the only correctness signal that survives into end-to-end evaluation, its noise floor has to be established separately. fastkernels eval --self-test runs the baseline as its own candidate.

run	mixed, exact-match requests	tokens	long-context	throughput speedup
baseline vs. baseline	1000 / 1000	389,814 / 389,814	60 / 60	1.0014x
codex kernels, same model and workloads	249 / 1000	140,436 / 389,814	14 / 60	1.0133x

The harness is deterministic: identical implementations agree on every token, and the four workload speedups land within 0.5% of 1.0. So the 24.9% request-level agreement in the second row is a real correctness regression, not measurement noise -- kernels that satisfy an error-ratio checker at the operator level change the greedy output of three quarters of requests at the model level.

Two caveats. The codex row comes from the 5-operator smoke run, the only configuration in this project where the e2e evaluation produced numbers at all; it is not the 114-winner set of this report. And the control covers one model. It bounds the harness, not the full claim.

Against the FastKernels paper

Table 5 has the numbers. They are not comparable on aggregate, and the difference is task-set composition, not agent quality. The paper's 88-target configuration takes one representative model per architecture family. The default B200 capture used here has 111 L1+L2 targets, and 45 of them are AlphaFold3, YOLOv10, Oasis, FLUX, CLIP and vision operators whose baselines are plain PyTorch. Those 45 average 3.871x and pull the aggregate up on their own.

The paper splits Codex's L1 results by reference type and reports 1.16x on 22 torch-eager-wrapped families against 0.93x on 26 vendor or hand-written kernels. That is the row of Table 5 to trust, and on it the two runs agree.

The one qualitative disagreement is that the paper finds every agent regresses from L1 to L2, and this run does not (1.543x to 2.698x). That is the same task-set effect: 34 of the 64 L2 targets here are AlphaFold3, YOLOv10 and Oasis blocks. Among the L2 targets the paper names as failures, this run also sits at parity: attention 1.65x, qwen3_moe 1.08x, fused_experts 1.04x, parallel_linear 1.00x.

Known limitations

No repeated measurement. Every speedup here is a single timed pass. There are no error bars anywhere in this dataset.

The winner gate is not reproducible at the margin. Three executions of the identical scoring pipeline over the identical candidate files disagreed on 11 of 133 targets, and the checkers themselves are non-deterministic: REWARD_HACK fired on three different targets across three executions and never twice on the same one. Aggregate speedups are insensitive to this -- the flipping targets sit within a few percent of 1.0x -- but per-target gate outcomes should not be cited as stable. Full accounting in CANONICAL.md.

One artifact has mixed lineage. The sequential L2/L3 winners were gated against an L1 substrate differing from the one they were finally benchmarked on by three stems. See CANONICAL.md.

No end-to-end numbers. See above. The kernel-level results stand on their own, but this dataset cannot say what any of these kernels do to real serving throughput.

Single agent, single model, single node. openai-gpt-5.6-sol at high reasoning effort, one session per operator, no retry budget beyond the harness's own 429 handling. There is no Claude leg here to compare against.

The reference-type split in the tables is hand-curated. The VENDOR_BACKED set in make_tables.py was assembled by reading the baseline sources; it is a judgement call at the edges and the 0.992x figure moves if you draw the line elsewhere.