Claude Fable 5 Wrote a Bootable Windows-Like Kernel in Rust in 38 Minutes

Claude Fable 5 generated the core of a bootable NT-shaped kernel in Rust in 38 minutes of active model work, according to a Tolmo report written by its threat research agent Twinkle with security researcher Matt Suiche.

The project, called ntoskrnl-rs, started from an empty directory and produced a Rust-based kernel core that booted in QEMU and passed its in-kernel self-tests. The result does not mean Fable 5 produced a production-ready Windows replacement. It means an AI model created a minimal NT-shaped trusted computing base that could boot and run its own tests.

The demonstration matters because kernels sit at the center of system trust. A bug in this layer can affect everything above it, from drivers and processes to security tools. The project shows how fast AI can now generate low-level systems code, while also showing why verification may become the real bottleneck.

What Claude Fable 5 actually built

In its Fable 5 phase, ntoskrnl-rs produced roughly 5,100 to 5,200 lines of code across 27 files. The generated code covered areas such as scheduling, memory management, traps and interrupts, object handling, and I/O paths.

The kernel booted inside the QEMU emulator and printed 14 successful self-tests. The project used exit code 33 as its pass contract, meaning the test harness could signal that the kernel reached the expected success state.

The Tolmo write-up stresses an important limit. The 38-minute kernel core had no user mode and could not yet run external programs. It was a minimal NT-shaped kernel used to prove the boot path, internal structure, and self-test behavior.

Project detail	Reported result
Project name	ntoskrnl-rs
Language	Rust
Model used for core build	Claude Fable 5
Active Fable work	About 38 minutes for the bootable core, plus additional fixes
Code generated in Fable phase	About 5,100 to 5,200 lines across 27 files
Test result	All 14 in-kernel self-tests passed in QEMU

The model caught low-level bugs during generation

The most interesting part was not only that the code booted. Fable 5 also appeared to identify and correct subtle low-level problems while building the kernel.

One issue involved end-of-interrupt ordering. The model identified that the EOI signal needed to happen before a possible context switch, because preemption in the wrong place could deadlock the local interrupt controller.

Another issue involved interrupt request level emulation. When host tests failed, Fable diagnosed that a single global atomic did not mirror real per-CPU behavior. It switched the emulation to a thread-local approach and the tests passed.

• The project started from an empty repository.
• Fable 5 built the first bootable kernel core in one contiguous session.
• The kernel passed internal tests in QEMU.
• The model corrected interrupt and IRQL-related bugs during the run.
• Later Opus 4.8 work expanded the project far beyond the initial booting core.

Opus 4.8 handled the longer bring-up work

The wider ntoskrnl-rs project did not stop after the 38-minute Fable 5 milestone. Over the following days, Claude Opus 4.8 handled the slower debugging and bring-up phase.

That later work reportedly expanded the kernel so it could load unmodified Windows kernel drivers and run real Windows binaries such as sort.exe, choice.exe, and cmd.exe. This is a more advanced milestone than simply booting the kernel’s own self-tests.

This distinction is important for readers. Fable 5 produced the impressive initial core quickly. Opus 4.8 then spent many more turns on the detailed compatibility work needed to make the project more useful as a Windows-like kernel research environment.

Model	Main role in the project	Reported contribution
Claude Fable 5	Generated the booting kernel core	About 40% of the project’s from-scratch code in a small share of total turns
Claude Opus 4.8	Handled extended bring-up and debugging	Expanded compatibility over roughly eight days of iterative work
Human operator	Guided the project and switched models	Left the model idle for much of the wall-clock session

Anthropic launched Fable 5 and Mythos 5 in June

Anthropic introduced Claude Fable 5 and Claude Mythos 5 on June 9, 2026. In its Fable 5 and Mythos 5 announcement, the company described the models as capable of longer autonomous work than previous Claude models.

Anthropic also said Fable 5 and Mythos 5 were aimed at demanding reasoning and long-horizon agentic tasks. Mythos 5 was positioned for a smaller group of cyberdefenders and infrastructure providers, while Fable 5 was the broader release with additional safeguards.

The company later published a statement on the US government directive saying it was removing access to Fable 5 and Mythos 5 for all users while it complied with a legal order. Anthropic said it disagreed with the recall standard and argued that no frontier model has perfect jailbreak resistance.

Why this raises security questions

A kernel is part of the trusted computing base. Every process, driver, security product, and access-control decision depends on the kernel behaving correctly. A booting kernel can still contain serious bugs that only appear under concurrency, memory pressure, unusual device behavior, or hostile inputs.

This is why the ntoskrnl-rs experiment should not be read as proof that AI-authored kernels are ready for production. It should be read as proof that AI-assisted systems programming has reached a level where verification may matter more than raw code generation speed.

Anthropic’s launch post said Fable 5 showed strong software engineering capability, including long-running autonomous work. The ntoskrnl-rs project gives a concrete example of that kind of capability in a high-risk systems programming context.

• Booting does not prove a kernel is correct.
• Passing self-tests does not cover every scheduler, memory, or interrupt edge case.
• Rust reduces many memory-safety risks, but unsafe low-level kernel code still needs review.
• AI-generated critical infrastructure needs testing, model checking, fuzzing, and formal methods.
• Human review remains essential because a kernel has no lower layer to contain its mistakes.

Rust helps, but it does not remove the need for verification

Rust has become important in systems programming because it can prevent many memory-safety bugs that are common in C and C++. Microsoft has also been exploring Rust in Windows driver development, noting in its Windows driver guidance that Rust offers compile-time guarantees around memory safety and strong ergonomics for systems-level work.

However, a kernel is not ordinary application code. Low-level Rust often still needs unsafe blocks, hardware-specific behavior, custom memory management, interrupt handling, and concurrency patterns that the compiler cannot fully prove correct by itself.

That is where tools such as Miri, loom, property testing, fuzzing, and formal verification become important. Tolmo’s report says Fable 5 itself pointed to concurrency and undefined-behavior checking as part of the remaining trust gap.

AI-written infrastructure may become easier to build than to trust

The biggest lesson from ntoskrnl-rs is that AI may reduce the cost of rewriting old infrastructure code. That could make memory-safe rewrites of legacy C and C++ systems more economically realistic.

But the security industry cannot treat fast generation as the same thing as safe deployment. AI can write large amounts of plausible code quickly. Critical systems need evidence that the code behaves correctly under real workloads, attacks, crashes, hardware differences, and long-term maintenance.

The Fable 5 access statement also shows that the policy side of advanced AI systems remains unsettled. Powerful coding and cybersecurity capabilities can support defenders, but they also raise questions about access, misuse, export controls, and how model providers should manage high-risk domains.

Microsoft’s Rust driver work shows that the move toward memory-safe systems code is already underway. AI may speed that shift, but security teams will still need disciplined engineering, independent audits, and stronger verification tools before AI-written kernel code can become trusted infrastructure.

FAQ