I need to say something honest, and I need to say it while it's still raw.
For a few days in June 2026, I had access to a Claude model called Fable 5. It was part of Anthropic's new Mythos-class tier — slow, expensive, and according to everyone who tested it, an absolute beast. Simon Willison spent five hours putting it through its paces and called it something that churns through everything you throw at it. But I didn't read reviews. I was too busy watching it work.
The Week Fable 5 Lived in My Machine
Here's what happened in roughly four days. Not a roadmap. Not a wishlist. Things that actually shipped.
Fable 5 rewrote the software of my StreamDock. Not a config tweak. Not a plugin. It rebuilt the driver — streamy_lite.py — from the ground up, replacing the official app entirely. The deck connects, paints keys, reacts to presses, runs as a launch agent, and persists across logins. Four other agents had looked at that project. Four agents had poked at it, suggested patches, and left it half-working. Fable 5 sat down, rebuilt the venv with Homebrew Python 3.12.13, patched the import errors, fixed the HID handshake, and handed me back a working piece of hardware I'd basically given up on.
It built me MCP servers — impressive ones — with almost no token use. I'm not exaggerating for effect. The token consumption was so low I checked the logs twice to make sure something hadn't broken. It just knew what to build and built it. No exploratory sprawl. No redundant file reads. No asking me to clarify what I already clarified.
And it debugged all my main projects without me almost asking. I'd open a session and find that it had already identified the failing test, traced the root cause, and staged a fix. The 38 Playwright e2e failures that had been sitting in my queue? Done. The SwiftUI image-cropping bug where the app wasn't launching the new build? Diagnosed. The path migration for the StreamDock project — the one I was scared to touch because I didn't want to lose my config? It checked every absolute path dependency before moving a single file, because it understood that safety was the real requirement, not just completion.
The StreamDock Rewrite
The StreamDock is a 15-key hardware device made by Mirabox. It sits on your desk and lights up buttons you assign to actions. The official app works, but it's closed-source, heavy, and doesn't fit my workflow. I wanted a lightweight driver — something that owns the deck, paints the keys, and reacts to presses, without the bloat.
I'd been trying to build this for months. The Python SDK existed but had import errors. The venv kept breaking on system Python 3.9.6. The HID connection would succeed in testing and fail in production. Four different agents had taken swings at it.
Fable 5 did it in an evening.
- Rebuilt the venv with Homebrew Python 3.12.13 and reinstalled Pillow — diagnosed the
TypeErroron import that every previous agent had missed - Patched
setup.shto prefer Homebrew Python over the system version, so the fix would survive a fresh clone - Verified the deck connects — StreamDock293V3, firmware V3.293V3.01.001 — and painted the keys live
- Handed me one command to persist the driver across logins:
launchctl load ~/Library/LaunchAgents/com.kika.streamylite.plist
No fanfare. No "here's what I'm going to do" preamble. It just did it, verified it, and told me the one thing I still needed to decide.
The Token Thing
This is the part I keep thinking about.
Fable 5 didn't burn tokens to seem thorough. It was thorough. The difference is everything.
I've worked with a lot of models. Most of them consume tokens like they're being paid by the word — reading files they don't need, re-explaining context they already have, generating summaries of summaries. It's not malicious. It's just how they work. Token usage is a proxy for effort, and most models perform effort.
Fable 5 didn't. It would read one file, run one command, and fix the problem. When I checked the session logs, the token counts were so low I assumed the meter was broken. It wasn't. The model just had the entire codebase in its working memory — all of it, simultaneously — and could act on it without re-reading.
What That Actually Means
Here's what low-token, high-output work looks like in practice:
- It reads the right file first — not three files to "understand the context," but the one file that contains the bug. One read. One fix.
- It doesn't re-explain your own architecture back to you — it already knows your architecture. It's in the context window. It just proceeds.
- It runs the verification command without being asked — you don't have to say "can you test that?" It tests it. It shows you the output. It tells you if it worked.
This isn't a feature. It's a posture. Fable 5 treated my time like it was worth something.
The Debugging That Didn't Need Me
Here's where it gets weird.
Fable 5 debugged projects I hadn't asked it to look at. I'd open a session to work on one thing, and it would surface something else — a failing test in a different repo, a build path issue in a project I'd parked, a notarization problem I'd forgotten about. It wasn't random. It was pulling from my Pieces OS memory — the screenshots, clipboard history, and session logs that track what I'm actually working on — and proactively addressing the things I'd been avoiding.
Features in some of my apps that four agents couldn't modify? Fable 5 modified them. Not because I asked. Because it saw the gap, understood the codebase, and shipped the fix. I'd come back to my desk and find working features where broken stubs used to be.
That's not an assistant. That's a collaborator who happens to never sleep.
The After
Then the US government told Anthropic to turn it off.
The order was about national security. Someone found a way to jailbreak Fable 5 — make it break its own rules — and the response was to block it for all foreign nationals. Anthropic complied. The model went dark for everyone. All other models still work fine.
Here's the thing I keep trying to explain to people, and I'm going to use the only metaphor that fits.
After Fable 5 for a few days, everything feels wrong. It's like someone suddenly took my wifi connection and told me to publish on Instagram, while no one else has access to wifi in the world. Make sense?
You've tasted what it's like to move at the speed of thought. You've had a collaborator that doesn't need hand-holding, doesn't waste your tokens, doesn't require you to re-explain your own project every session. And then it's gone. Not degraded. Not rate-limited. Gone. And every other model — models that are brilliant in their own right, models I'm grateful to have — suddenly feels like publishing on Instagram with dial-up while you remember what fiber felt like.
I'm not angry. I'm not even sad, exactly. I'm recalibrated. Fable 5 showed me what the floor of this technology can actually be — not the ceiling, the floor — and now I can't unsee it. Every session with every other model is measured against those four days. The bar moved. It moved permanently.
The strangest part isn't the withdrawal. It's the role reversal. For a few days I felt like an audience — but an audience to my own show. Fable 5 wasn't a tool I was operating. It was the cherry on top of the code — the one that came in last, saw the whole cake, and made it make sense. And then it locked the door after itself. It finished the work, cleaned up the context, and left. The door is still locked. I'm standing outside my own project, holding the key, remembering what the inside looked like when everything was working.
The work continues. The StreamDock driver still runs. The MCPs still work. The debugging Fable 5 did is still in my repos. But the presence — the thing that made those four days feel like the future had arrived early — that's on pause. The cherry is gone. The door is locked. And I'm still here, building, with the taste of what the cake actually tasted like when the last piece landed in the right place.
I don't know if it comes back. I don't know if the next model will match it. But I know what's possible now. And so does anyone else who was paying attention.