Fable 5
【Intro】AI can now handcraft CUDA from scratch to squeeze every last drop of GPU performance! Fable 5 surges to a 18.7x speedup to claim the top spot, outperforming GPT-5.5 by over 4x. Anthropic co-founder exclaims: The RSI self-evolution era has begun.
An AI has written the fastest kernel in history!
In the new round of GPU operator benchmark tests KernelBench-Mega, Fable 5 pulled far ahead of all competitors.
On the RTX PRO 6000, it achieved a staggering 18.7x speedup through fully handwritten CUDA code.
In comparison, even the powerful Claude Opus 4.8 only reached 14.4x, while GPT-5.5 scored merely 4.34x.
Fable 5 left the second-place model more than 4x behind, securing an overwhelming, unbridgeable lead.
The person who made this definitive judgment is Jack Clark, co-founder of Anthropic.
His verdict can be summed up in one sentence: This marks the beginning of the "Recursive Self-Improvement (RSI) loop".
Fable 5 Hits 18.7x Speedup, Surpasses GPT-5.5 by a Wide Margin
The AI has written the world's fastest low-level code, not only outpacing human performance in speed but also achieving extreme levels of code "purity".
It's important to note that KernelBench-Mega is no ordinary benchmark test.
It no longer tests patching isolated, single operators, but instead forces the entire model's computation blocks into the kernel to perform deep operator fusion —
The challenging test task this time is 02_kimi_linear_decode, a mixed decoding task for Kimi-Linear W4A16 (4-bit weights, bf16 activations).
The rules are extremely strict: each model is granted only one independent session, with a hard 3-hour real-time limit to push performance to its maximum.
The performance results Fable 5 delivered essentially slammed the physical performance limit straight in the face of its competitors:
Fable 5: 18.71x
Opus 4.8: 14.4x
GPT-5.5: 4.34x
Sonnet 5: 4.0x
Even more counterintuitive: the longer the context window, the faster it runs!
It reached 17.8x speedup at 2K context, expanded to 18.9x at 8K, and surged all the way to 19.5x when the context was stretched to 16K.
As we all know, with a longer context window, the KV Cache inevitably expands, and the attention computation cost per token spikes sharply.
This is typically the biggest pain point that causes severe performance drops in decoding kernels.
But Fable 5 aggressively packed all computations into a single Kernel Launch, drastically amortizing the fixed barrier synchronization overhead;
At the same time, its int4 computation efficiency pushed the hardware's memory bandwidth to its absolute upper limit.
The result is that while other models hit performance bottlenecks, the performance gap between Fable 5 and the baseline did not shrink — it kept widening as the workload pressure increased.
The First-Ever "True Megakernel" in History
What truly sent chills through the industry is not just this speed performance.
What Fable 5 wrote is the very first genuine "megakernel" in KernelBench-Mega history.
The so-called "megakernel" compresses the entire inference pipeline into a single kernel that runs continuously without intermediate data offloading or context switching.
This is widely recognized as one of the most challenging programming patterns in GPU development.
Even experienced human engineers struggle with it, and no model on the leaderboard had ever truly achieved it before.
Where exactly does its "purity" lie?
A stunning detail can be observed through torch.profiler:
When decoding each individual token, Fable 5's kernel only performed exactly one cooperative launch.
int4 dequantization, convolution, SiLU activation, KDA gating delta states, MLA implicit attention computation, MoE routing with top-8 expert selection, various RMSNorm operations, and even KV cache writes —
All of these tasks are packed into this single launch, executed in stages across 14 grid barriers.
By contrast, every other high-scoring model has to split the task into 4 to 14 separate kernel launches to barely complete the computation.
One launch versus fourteen.
This difference is no trivial matter. Every time a kernel is launched, the GPU must pause and perform handshaking operations, wasting idle cycles that add up to lost time.
While others split the work into a dozen separate steps, Fable 5 bundles all tasks into one single execution. All that saved time translates directly to pure performance gains.
2.5 Hours, 550,000 Tokens for One-Shot Kernel Development
Fable 5 did not start writing the kernel by rushing to type code immediately.
Throughout the entire session, it spent 64% of its time in "silent" work — quietly benchmarking the baseline performance, running microbenchmarks for grid barriers, and deriving a roofline upper bound of "approximately 29 bytes per token".
Link: https://huggingface.co/datasets/Infatoshi/kernelbench-mega-traces/blob/main/20260701_172615_claude_claude-fable-5_02_kimi_linear_decode.jsonl
After completing all this preparatory work, it wrote the entire kernel in one go, and hit a 14.4x speedup on its very first benchmark run.
Then, over the final hour, it removed redundant barriers and optimized int4 dequantization to be almost "free", pushing its performance all the way up to 18.7x.
It tried a suboptimal optimization once, immediately rolled back the change after testing, and made no excuses — it only trusted the hard data.
The entire process took just 2.5 hours, using approximately 550,000 tokens.
The most easily overlooked detail here is that —
Fable 5 is only the "safety-aligned version" of Anthropic's internal model Claude Mythos.
The "AI Self-Evolution" Loop Has Begun
That's exactly why Jack Clark, Anthropic's co-founder, made a bold judgment in the latest issue of Import AI —
This marks the official launch of the "Recursive Self-Improvement" (RSI) loop.
For the subtitle of this issue, he left only one line: Is this the dawn of a new world?
His reasoning is straightforward: the ability to independently develop and optimize kernels is one of the most fundamental underlying tasks in AI R&D.
The better AI becomes at writing kernels, the faster training and inference run; faster performance leads to more powerful next-generation models; more powerful models in turn write even better kernels —
Once this flywheel starts spinning, it will barely need human intervention to keep accelerating.
Fable 5 is not just leading the way in the task of "building itself" — it has also started taking over work that used to belong exclusively to humans.
Recently, on the Remote Labor Index, AI task completion rates have surged from 2.5% when the platform launched in October 2025 all the way up to July 2026.
In less than eight months, the state-of-the-art performance has more than quadrupled.
Clark notes that the rate at which AI is expanding its own economic boundaries is now outpacing the speed at which humans can redefine their "comparative advantages".
Half Sprinting Forward, Half Full of Awe
Interestingly, at the end of this same issue of Import AI, Jack Clark wrote a science fiction story —
A world in 2050, where "general-purpose computers" have been manually banned by humanity for being far too dangerous.
In the post-"Great Collapse" world, only analog computers built from plumbing pipes, containers, and brass gears are left, running clumsily —
To predict the weather, mountains must be built into hardware as fixed impedance structures;
To simulate floods, electronic circuits must be woven into real riverbed terrain.
The very person who declared "the RSI loop has begun" turned around and imagined a world where general computing is locked away in a cage.
This is probably the most real "sense of dissonance" of the moment: half is unbridled sprinting forward, the other half is full of deep awe.
Over a year ago, when KernelBench was first released, the then-strongest OpenAI o1 only achieved a 4% score on the hardest tasks.
Today, AI is already writing its own drivers.
It took humanity decades to push GPUs to the performance limits we have today. Fable 5 did it in just 2.5 hours.
The countdown may have already quietly begun.
References:
https://x.com/elliotarledge/status/20728