Let's address the capybara in the room
Towards an appreciation of tokenomics
Claude Fable is the most intelligent and capable AI model publicly available today. It’s the safetymaxxed version of Mythos, and is essentially the same underlying model, but wrapped in guardrails.
OpenAI is said to be making GPT-5.6 available soon, so shortly we’ll see how it stacks up in terms of frontier capability. Anyone following me for a minute knows I’m codex pilled, but my intuition is Anthropic might potentially still hold the lead for a while longer with Mythos.
I first wrote about the model back in April, shortly after a draft announcement, which described the new tier as Capybara, leaked out of Anthropic’s CMS. In that same month, Anthropic provided a preview of Mythos to partners as part of Project Glasswing.
On June 9, they gave Fable to us plebeians and life was splendid. This model slaps. With the right context, it can run unattended longer to complete a task, a trend we continue to see. The problems it can handle are more complex and nuanced.
I’m going to conveniently skip over the drama between Anthropic and the US Government that occurred starting on June 12, because I feel like it’s already well covered elsewhere and besides there is a lot that still isn’t consistently candid about the situation.
Fable came back to us on July 1, and we’re back off to the races once again.
But let’s back up for a moment to late last year.
A very codex Christmas
The software industry had something of a reckoning late last year when Opus 4.5 released and many considered we crossed a threshold at that time.
I don’t quite see it that way. If you’ve been jacked into the inference matrix all day every day since November 2022, it’s been more like one long gradient of increasing capability, and less of a step function.
Naturally, we get a bump in capability in every model release, but at the same time we are learning and still very much learning about how to actually use these models. I’m referring to things here like harnesses, managing context, subagents, loops and so on. Those things in equal part propel our understanding and ability to write and maintain software using large language models.
Anyway, Opus 4.5 released around Thanksgiving, but the collective recognition that things have changed came over the break when everyone went home and vibe coded their minds away on personal projects. And like a drug dealer, Anthropic and OpenAI both pumped us full of resets. We all came back in January with full blown LLM psychosis.
At that point, most people realized though that there was no putting the toothpaste back in the tube. If you had any prior doubt, now you knew that the future of programming is agentic.
Someone gotta pay the bill
And I guess that would bring us to the sadly pathetic period of tokenmaxxing. For a few months, parts of Silicon Valley appeared to confuse “using AI” with “burning as many tokens as possible.”
Meta had an internal employee-built leaderboard called Claudeonomics, ranking the company’s top token users and handing out titles like “Token Legend” and “Cache Wizard.” The top user reportedly averaged 281 billion tokens in a 30-day period.
Who knows those might be rookie numbers in the future, but for the time being those numbers have a real cost. And like a lot.
Amazon had its own version of an internal leaderboard, which later shut down after employees naturally started gaming it by running agents on work that did not need doing.
Uber managed to blow through its 2026 token budget in four months. Across the industry we are seeing at least some degree of scaling back on token spend after feeling the sticker shock. It turns out the future of work is expensive especially if you don’t approach this problem intelligently.
Stop setting money on fire
In the future, I’m bullish on abundance. Capability will continue to scale, and cost per unit of intelligence will continue to fall. The same task will get cheaper.
But that does not mean our total spend goes down. It probably means the opposite for a while, because the tasks themselves expand to fill the available intelligence.
Fable is a beast compared to where we were a few years ago. It is also expensive enough that if you approach it without strategy, you are going to light money on fire.
There are a few levers to pull though. Let me first mention that OpenAI tried to make routing feel invisible with GPT-5, and in my view they mostly missed, too early, but were at least directionally right. Not every task, or even every unit of a task, deserves the same amount of intelligence.
We should study routers more carefully and continue to press in that direction at that model level. But we don’t have to wait for the labs to solve all of it. We can already do a lot inside the harness.
Fable as advisor
Anthropic suggests two patterns in particular with Fable. The first consists of using Fable as an advisor. Sonnet does the work and owns the main loop. But it has a special trick up its sleeve: the advisor tool, which lets it phone Fable when it needs judgment.
Mechanically this is more interesting than it sounds. The advisor call is a server-side tool. Sonnet emits a tool call with a literally empty input, and Anthropic’s infrastructure forwards the entire transcript to Fable in a separate inference pass.
Fable reads all of it, writes back a plan or a course correction, and Sonnet keeps grinding. All of this happens inside a single API request. The executor signals the timing and the server supplies the context.
Two details are worth knowing before you deploy it. Understand that the advisor runs in the blind. It gets no tools, and its thinking blocks are dropped before the result comes back. Only the advice text reaches Sonnet. And if your advisor is Fable or Mythos, the advice is hidden from your application. You simply round trip an encrypted placeholder, and Anthropic restores the original advice internally on the next turn.
The economics only work because the advisor doesn’t generate your output. Advisor calls bill at Fable rates, but typical advisor output is a few hundred text tokens of guidance. Sonnet then produces the actual deliverable.
The docs also recommend capping advisor output at max_tokens: 2048, which in Anthropic’s testing cut mean advisor output roughly 7x with essentially no truncation and no measurable quality loss.
On SWE-bench Pro, Anthropic reported Sonnet 5 with Fable 5 advisor hit about 84% accuracy versus roughly 75% for Sonnet alone and 91% with pure Fable. Anthropic frames it as ~92% of Fable’s score at ~63% of the price, with Fable getting called roughly once per task.
Fable as orchestrator
The second pattern is Fable as the orchestrator. Now Fable is doing the driving. It reads the tasks, breaks it apart, and fans out the execution to a pool of Sonnet workers, each running its own loop in its own isolated context.
This one lives in Claude Managed Agents, Anthropic’s hosted agent runtime, rather than in the Messages API. You define a coordinator agent (Fable) with a roster of subagents (Sonnet workers), and at runtime the coordinator spawns session threads as it delegates.
Everything shares one sandbox and filesystem, but each thread keeps its own conversation history. Interestingly, threads are persistent too, so the orchestrator can follow up with a worker that retains everything from its earlier turns.
Anthropic tested this on BrowseComp, a benchmark of genuinely nasty web research questions where most of the cost is churning through pages. A Fable 5 orchestrator with Sonnet 5 worker subagents Anthropic reported 86.8% accuracy at $18.53 per problem, against 77.8% at $16.01 for all-Sonnet and 90.8% at $40.56 for only Fable. That’s 96% of Fable’s performance at 46% of its cost.
So basically if you’re running only Fable, you’re paying the most expensive rates for a frontier model to just read search results, which is exactly the waste that this pattern addresses. And one more detail to point out is that each subagent keeps its own prompt cache, so when the orchestrator sends a followup to a worker, that worker isn’t repaying full input price for context it already holds.
Picking between them (and a third option)
The way I think about it is use the advisor when the work is fundamentally sequential and most turns are mechanical. Use orchestrator when the work decomposes into independent token burning subtasks. Advisor is escalate up, and orchestrator is delegate down.
Let me close by mentioning one more option. If you’re running the orchestrator workflow with access to both Anthropic and OpenAI APIs, you should ask Fable to make Codex the workhorse. Peter Steinberger has published the codex-first skill that can wire this up.
This is likely looking to me like my current preferred setup. Once you accept the frontier model’s current job is judgment and the workhorse’s job is tokens, the workhorse becomes a commodity slot. You fill it with whatever is the cheapest that clears the quality bar this month.
It’s early still yet and I can’t wait to explore these ideas some more. Happy hacking!