I teach AI systems the same way I learned engineering: with analogies.
And the one that keeps coming back when I watch people use Fable 5 is this: you don't hire a senior architect to pour concrete. You hire them to design the building, review the structural plans, and sign off on the work. The crew that pours the concrete is skilled, reliable, and costs a fraction of the architect's rate.
Running everything through Fable 5 is hiring the architect to pour the concrete.
It works. The building gets built. But you're paying $50 per million output tokens for work that an $6 model handles at near-parity. And after July 12, every token Fable 5 produces comes out of credits you have to buy.
The pattern that fixes this has a name. It's called orchestration. Fable 5 is the orchestrator. Grok 4.5 - which launched yesterday - is the implementer. And you have four days to set it up while Fable is still free.
What Orchestration Actually Means
Most people use AI the same way: one model, one chat, do everything.
That's fine for simple tasks. But for anything that involves real work - research, drafting, analysis, building something - you're mixing two very different types of thinking into one conversation. Planning and executing. Judging and producing. Deciding and doing.
Fable 5 is extraordinarily good at the first half of each of those pairs. Anthropic's own documentation says it outright: Fable 5 is "significantly more dependable at dispatching and sustaining parallel subagents, and reliably manages ongoing communication with long-running subagents and peer agents." That's the orchestrator job description.
Grok 4.5 is built for the second half. SpaceXAI released it yesterday, July 8, positioning it specifically for coding, agentic tasks, and knowledge work. It's not as strong as Fable 5 on the hardest benchmarks - Fable leads 92 to 75 on the aggregate - but on execution tasks, the gap narrows significantly. And it costs $2 per million input tokens compared to Fable's $10. On output, it's $6 per million versus Fable's $50.
That's the math. Fable does the 10% that requires real judgment. Grok does the 90% that requires reliable execution. The overall cost of a session drops by 5 to 10 times.
Every serious team running AI at scale in 2026 is doing some version of this. Most individuals aren't. That's the gap this guide closes
What Each Model Actually Does
The routing decision sounds complicated. It's not.
Before the breakdown, one distinction that makes the whole thing clearer.
The model you pick controls what Claude knows. The effort level controls how hard it tries. These are two independent dials, and most people only think about one of them.
Fable 5 is the specialist. The one you call when the problem is hard enough that everyone else is already at their limit. Even at lower effort, Fable spots what other models would miss. That's not thinking time. That's depth of knowledge built into the model that no prompt can replicate. Grok 4.5 is the capable generalist built for execution. Great at following a precise brief, fast, and dramatically cheaper. The effort level decides how long either one spends on your task - but only the model determines what it's capable of in the first place.
Here's the clearest version I've found: Fable 5 owns every moment where getting it wrong has consequences. Grok 4.5 owns every moment where the task is well-defined and the risk is low.
Fable 5 handles:
Reading a vague goal and figuring out what's actually being asked
Breaking a complex task into steps that can each be checked independently
Deciding which parts require judgment and which parts are mechanical
Writing the brief that tells Grok exactly what to do
Reviewing Grok's output for accuracy, coherence, and completeness
Making the call on whether the final output is ready to use
Grok 4.5 handles:
Executing the brief Fable wrote
Writing the first draft based on a detailed spec
Formatting, reformatting, restructuring
Processing a defined set of inputs according to clear rules
Generating variations of something already approved
Running the repetitive part of any workflow
The rule of thumb: if the next step requires a judgment call, it stays with Fable. If the next step is execution against a clear spec, it goes to Grok.
One more thing worth knowing: every time Grok implements something that Fable reviews, you get cross-vendor review for free. Models from the same family share blind spots. An independent implementation from a different model lineage - different company, different training, different assumptions - catches errors that same-family review misses. You're not just saving money. You're building in a second opinion at the structural level.
The Three-Step Non-Technical Workflow
This doesn't require Claude Code. It doesn't require a developer. It's three prompts and two browser tabs.
That's the whole setup.
Step 1: Give Fable the goal. Get back an execution brief.
Open Claude.ai. Select Fable 5 from the model selector. Give it your task using this prompt:
I need [describe your task in plain language].
Before producing any output, write me a detailed execution brief
that includes:
- Exactly what needs to be done, in what order
- The quality standard to hit
- Which decisions require judgment vs which are mechanical
- What the finished output should look like
I'll delegate the mechanical execution to a different model.
Make the brief specific enough that another model can execute it
without asking me questions.Fable reads your goal, thinks through what's actually being asked, identifies the risks and decisions, and hands you a brief written for execution.
That brief is the deliverable from this step. Save it.
Step 2: Hand the brief to Grok 4.5 for execution.
Open grok.com. Start a new conversation. Paste this:
Here is the brief for this task:
[paste Fable's execution brief exactly as written]
Execute this brief. Produce the finished output.
If anything in the brief is ambiguous, make the most reasonable
assumption, implement it, and note the assumption at the bottom.
Don't ask me questions. Make a call and show me the result.Grok reads the brief, executes it, and returns the output.
The brief Fable wrote is specific enough that Grok doesn't need to figure out what you want. It just needs to do the work. That's what makes the handoff clean.
Step 3: Bring Grok's output back to Fable for review.
Return to Claude.ai. Fable 5 is still in Tab 1. Paste this:
Here is the execution brief you wrote:
[paste the brief]
Here is the output the executing model produced:
[paste Grok's output]
Review it against the brief. Tell me:
1. Does it meet the quality standard you specified?
2. What's missing, wrong, or inconsistent?
3. Is it ready to use, or does it need revision?
If it needs revision, write the specific fix instructions I'll
pass back to the executing model.Fable reviews Grok's work from a fresh perspective. It wrote the spec. It knows what "good" looks like. And because it's a different model family than Grok, it's not going to miss the same things Grok might have missed.
When the output still isn't right
If you've run the loop twice and it's still falling short, here's the diagnostic before you change anything.
Ask yourself: did the model not know enough? Or did it not try hard enough?
If Grok's execution feels shallow or misses something obvious in the brief, it probably didn't try hard enough. Tell it to redo the task and be more explicit about the quality bar you expect.
If Fable's planning brief feels vague or its review misses real problems, same answer. Tell Fable: "Go deeper. What are you not catching?"
If both models are genuinely working hard and it's still wrong, that's a knowledge problem - not an effort problem. The fix is upstream: make the brief more explicit, or bring more context into Fable's planning step.
The fix is almost never "use a different model." It's almost always in the brief, the context, or the quality standard you gave Fable to work from.
A Real Example
I ran this for a newsletter research session last Tuesday between lectures.
The goal: Research the five most important developments in AI agents this month, and produce a structured brief I can use for a premium guide.
What I gave Fable: The goal, my usual quality standard for newsletter research (specific, no hype, concrete examples, sourced where possible), and the format I wanted.
What Fable returned: A 400-word execution brief. Research questions, source categories to check, the format for each finding, and a list of red flags to avoid.
What I gave Grok: The brief. That's it.
What Grok returned: Five structured research summaries, each following Fable's format, with sources noted.
What Fable did with Grok's output: Flagged one finding that cited a source without verifying the claim, suggested a sharper angle on two of the five summaries, and cleared three of them as ready to use.
Total time: about 25 minutes. Total Fable tokens used: the planning brief and the review. The research itself - the heavy lifting - ran on Grok at $2 per million input tokens.
After Alfie's walk that afternoon, the guide brief was sitting in my Cowork folder ready to build from. Fable thought. Grok executed. I barely touched either one.
The Technical Setup (Brief)
If you're a Claude Code user and want this automated - subagents running in parallel, Grok handling implementation while Fable orchestrates - the mechanism is already built.
In Claude Code, every subagent takes a model field in its frontmatter. Set the session to Fable 5. Drop a Grok subagent into .claude/agents/:
---
name: grok-implementer
description: Use this agent to execute well-defined implementation
tasks, write first drafts from a spec, process structured inputs, or
handle any task where the brief is clear and execution is the
bottleneck.
model: grok-4.5
---
You are an implementation specialist. You receive precise briefs and
execute them completely. Make reasonable assumptions on ambiguities,
note them, and keep moving. Never ask clarifying questions.Install the Grok CLI at x.ai/cli, run grok login, and the agent routes automatically. Fable orchestrates. Grok implements. You talk to Fable and the system handles the rest.
The fable-advisor plugin on GitHub (DannyMac180) ships this pattern pre-built, including a Codex lane for a second implementation perspective. Worth installing if you're already in Claude Code.
Why July 12 Is the Right Deadline for This
Here's the honest version of why this week matters more than any other.
Fable 5 is free through July 12. That means every Fable token you spend right now - planning, writing briefs, reviewing Grok's output - costs nothing beyond your existing plan.
After July 12, Fable costs credits. But if you've already built the routing habit, Fable's credit consumption drops dramatically. The orchestrator emits judgment, not volume. It writes the brief. It reviews the result. The heavy token spend - research, drafts, execution - is already on Grok.
You're spending Fable credits on the 10% that actually needs them. The 90% runs at $2 per million.
Use the four days to run this workflow on real tasks. Learn where the routing works cleanly and where you need to adjust the brief. Tune it while it's free.
When July 12 arrives, you're not scrambling to figure out what to do with Fable credits. You already know exactly what Fable is worth paying for. Because you've already built the system that makes it worth it.
One model thinks. One model builds. Four days to set it up for free.
Share this with one person still running everything through Fable and watching the credit estimate climb. That's all I'm asking.
Want to access all premium guides?
Become a paying subscriber to get access to this post and all other premium content.