On June 12 2026 Anthropic released Claude Fable 5. Nobody noticed at first. There was no press release, no benchmark announcement, no livestream. The model just showed up in the Claude Code dropdown.

Over the next two weeks it migrated one million lines of Bun from Zig to Rust. It landed a rocket on the moon in an unguided simulation. It ran unattended 72 hour test runs. Nobody was tweeting about MMLU scores. People were just using it to do work that would have taken engineering teams quarters.

Then on July 16 Kimi dropped K3. It beat Fable 5 on the Frontend Code Arena. It will be fully open sourced on July 27.

Everything changed.

The thing nobody benchmarked

Everyone was still arguing about standard exam scores when Fable 5 arrived. The model does not top most general purpose leaderboards. It does not set records on trivia evals.

What it does is run for 8 hours without you checking in.

This is the capability that every benchmark misses. Every existing LLM eval measures what a model can do in one turn. Nobody measures whether a model can remember your goal after 120 tool calls, 40 compiler errors, and three dead ends. Nobody measures whether it will give up, go in circles, or quietly fix the problem and tell you when it is done.

Cursor built CursorBench exactly because this gap had become ridiculous. On that benchmark Fable 5 hit 72.9%. The previous record was 58.1%.

Most importantly: this is not a capability you can fake. You either can land the rocket or you can't. You either can migrate a million lines of code and pass the test suite or you can't.

The million line migration

This is the single most important thing that has ever been done with an AI agent. Full stop.

Jarred Sumner migrated the entire Bun runtime, 1,000,000 lines of production Zig, to Rust in 12 days. The full test suite passed before merge. 19 regressions were found after shipping. All were fixed.

This was not a human assisted port. This was not Jarred writing code and the model helping. This was Jarred writing a rulebook, pressing go, and fixing the process when it broke.

The total cost was $165,000.

Before Fable 5 this project would have taken 6 senior engineers 18 months. That is roughly $1.8M in fully loaded engineering cost. It would have been considered one of the most successful large language migrations ever completed.

Now it is a template. Anthropic published the exact 6 step process they used. Any team can copy it.

Metric	Pre-Fable 5 baseline	Fable 5 execution
Timeline	18 months	12 days
Engineering headcount	6 full time	0.5 part time
Total project cost	$1,800,000	$165,000
Typical post merge regressions	100-300	19
Risk profile	High failure probability	Disposable throwaway branch

This is not incremental improvement. This is a step change.

How the migration loop works

Nobody hand edited a single line of code during the Bun port. That is the part almost everyone misses.

When an error was found, nobody fixed the code. They fixed the rule that produced the code. Then they regenerated every affected file.

This is the core insight. You do not debug output. You debug the loop that produces output.

Fable 5 is good enough that this works. It will reliably follow the rulebook. It will reliably review other agents work. It will reliably categorize errors and suggest changes to the rules.

Every prior model would drift. Every prior model would ignore instructions half the time. Every prior model would require a human to intervene every 10 minutes.

Fable 5 does not drift.

What Fable 5 actually changed

Prior to this release, all agent demos worked like this: you show a 90 second clip of the agent doing something impressive. You do not show the 12 times it failed before that run. You do not show the human babysitting it the whole time.

Fable 5 is the first model where you can walk away.

Cursor's Nate Schmidt put it best: you use Fable 5 when you do not know where B is. When you know the path from A to B you use a cheaper model. When you have no idea what the path even looks like, you use Fable 5.

This is the dividing line. All prior models were assistants. You still had to know the answer. Fable 5 is a colleague. You just have to know the goal.

It also changes what projects are even worth doing. Before Fable 5 a migration needed an existential business case. Now one chronic performance bottleneck, or one year of memory bug patches, is enough justification.

The trace dataset

One week after the migration blog post went live, Glint Research uploaded 4665 full agent traces from Fable 5 to Hugging Face.

This is the most important dataset released this year. It is not synthetic. It is not benchmark questions. These are real traces of the model actually doing work.

Trace metric	Measured value
Total complete sessions	4665
Tool call outputs	3799
Median reasoning length per step	2365 chars
P90 steps per full session	207
Longest recorded session	439 steps

81% of all outputs are tool calls. Not text. Not chat. The model spends almost all of its time running commands, editing files, reading output, and adjusting.

You can load every single one of these traces and watch exactly what the model did. You can see every mistake it made, every correction, every dead end it backed out of.

This is not how frontier models used to work. You used to get a black box that output answers. Now you get a full audit log of every thought.

Then Kimi showed up

14 days after the Bun migration was published, Kimi dropped K3.

It beat Fable 5 on Frontend Code Arena. It came third on Artificial Analysis, beating Opus 4.8. It will be fully open sourced, full weights, on July 27.

This is the part that broke everything.

For three years everyone accepted that frontier capability was locked behind closed walls. Only OpenAI and Anthropic could do this. Everyone else was 6-12 months behind.

That is no longer true.

K3 is not perfect. Official statements explicitly say it still lags Fable 5 and GPT 5.6 on overall capability. It burns too many tokens. It overthinks simple tasks. It does not hold context as well over very long runs.

None of that matters.

It is good enough. It is open. And it is here right now.

The frontier is now public

This is the end of the closed frontier.

Up until this month you could argue that closed models had an insurmountable lead. You could argue that safety concerns justified keeping this capability restricted. You could argue that open models would always be one generation behind.

All of those arguments died on July 16.

We are not looking at a gap measured in years anymore. We are not looking at a gap measured in months. We are looking at a gap measured in weeks.

K3 already matches Fable 5 on one of the most important practical benchmarks. The next one will match it on more. The one after that will exceed it.

And every single one of them will be open source.

What comes next

Nobody is building general purpose chatbots anymore. That game is over.

Everyone is building agents. Everyone is building loops. Everyone is working out how to run these things unattended for days at a time.

The conversation has already moved on. Nobody is arguing about which model is number one. People are arguing about how to structure agent loops. How to build good judges. How to debug 1000 step runs. How to know when you can trust the output.

Fable 5 did not win the race. It ended the old race and started a completely new one.

The most important capability is no longer how well a model answers trivia questions. It is how reliably it can run for 1000 steps without human intervention. It is how well it can follow rules. It is how well it can debug itself.

That is the new frontier. And it is open now.