Fable 5 opens a wide lead in KernelBench-Mega
Fable 5 posted the top result in the latest KernelBench-Mega GPU operator benchmark. On RTX PRO 6000, the model reportedly achieved a 18.71x speedup using a fully hand-written CUDA kernel. That placed it comfortably ahead of Claude Opus 4.8 at 14.4x, GPT-5.5 at 4.34x, and Sonnet 5 at 4.0x. Based on the published figures, Fable 5 outperformed GPT-5.5 by more than four times, giving it a clear lead over the rest of the field.
The workload used in the benchmark was 02_kimi_linear_decode, described as a Kimi-Linear W4A16 mixed decoding task with 4-bit weights and bf16 activations. Unlike simpler benchmarks focused on isolated operators, KernelBench-Mega evaluates whether a model can fuse larger blocks of a model’s computation into as few GPU kernel launches as possible. The setup was also restrictive: each model was given only one autonomous session and a hard wall-clock budget of three hours.
Performance also improved rather than deteriorated as context length increased. The published results show 17.8x at 2K context, 18.9x at 8K, and 19.5x at 16K. That matters because longer contexts typically expand the KV cache and increase per-token attention cost, which is usually where decoding kernels begin to lose efficiency. In this case, the gap between Fable 5 and the baseline grew as the workload became more demanding.
The first true single-launch megakernel in the benchmark
The more important point may be the implementation rather than the score itself. According to the report, Fable 5 produced the first true megakernel in KernelBench-Mega. In practical terms, that means compressing an entire inference path into one GPU kernel launch instead of splitting the work across multiple launches and intermediate handoffs. This style of GPU programming is generally considered one of the hardest to execute well, and the article says no prior model on the public leaderboard had completed the same level of end-to-end fusion.
Citing torch.profiler output, the article says Fable 5 used exactly one cooperative launch for each decoded token. Inside that single launch, it executed the workload in phases separated by 14 grid barriers. Those phases reportedly covered int4 dequantization, convolution, SiLU, KDA-gated delta state logic, MLA latent attention absorption, MoE routing with top-8 experts, multiple RMSNorm steps, and KV cache writes. By contrast, other high-scoring models still needed to decompose comparable work into 4 to 14 separate kernel launches.
The difference between one launch and many launches is not cosmetic. Every additional kernel launch introduces scheduling, synchronization, and idle overhead on the GPU. By collapsing the workflow into a single launch, Fable 5 was able to amortize fixed synchronization costs across a larger body of work. The report also says its int4 compute path was pushed close to the memory bandwidth ceiling of the hardware, helping explain why it maintained strong scaling even as context length increased.
Built and optimized in 2.5 hours with roughly 550,000 tokens
The article says Fable 5 completed the kernel writing and optimization process in about 2.5 hours, using roughly 550,000 tokens over the session. Notably, it did not begin by immediately generating code. Instead, about 64% of the session was reportedly spent on measurement and analysis, including timing the baseline, running microbenchmarks on grid barriers, and deriving a roofline bound described as about 29x bytes per token. Only after that preparation did the model write the full kernel.
Its first benchmark run was said to hit 14.4x immediately. During the final hour, Fable 5 then removed barriers, reduced overhead further, and pushed int4 dequantization close to effectively free in the final profile, ultimately lifting the result to 18.7x. The report also notes that one attempted optimization degraded performance and was rolled back after measurement. Another detail highlighted in the article is that Fable 5 is described as only the “safe version” of Anthropic’s internal Claude Mythos model, a point likely to fuel additional interest in its full ceiling.
Jack Clark says this may mark the start of recursive self-improvement
Anthropic co-founder Jack Clark argued in the latest issue of Import AI that the result may signal the start of a recursive self-improvement, or RSI, loop. His reasoning is straightforward: the ability to design and optimize GPU kernels sits close to the foundation of AI research and deployment. If a model can improve the low-level systems used for training and inference, then future models can be trained and served more efficiently. Those stronger models may then become even better at systems optimization, creating a compounding feedback cycle.
The article also links this development to broader changes in AI labor substitution. It cites data from the Remote Labor Index, saying completion rates by AI have risen sharply since the index launched at 2.5% in October 2025 and continued climbing into July 2026. Clark’s broader claim is that AI may now be expanding its economic frontier faster than humans can reorganize comparative advantage in response.
Beyond the benchmark, the debate is shifting toward control and limits
The same issue of Import AI reportedly ended with a science-fiction scenario set in 2050, where general-purpose computing had become dangerous enough that humans chose to restrict or ban it. That juxtaposition matters. The person saying the RSI loop may have begun is also imagining a future in which society tries to contain advanced computation. Together, those views capture a growing split in the industry: excitement over the pace of technical progress, and unease over governance, safety, and loss of control.
The timeline underlines how quickly capabilities have moved. The article notes that when KernelBench first appeared a little over a year ago, OpenAI o1 scored only 4% on the hardest tasks. Now, a model is being credited with planning, benchmarking, writing, testing, rolling back, and refining a complex CUDA kernel under a fixed time budget, while also producing a single-launch megakernel that had not previously appeared on the benchmark. For AI infrastructure, model efficiency, and automated systems engineering, the result is a meaningful signal to watch.