How to Enable Claude Fable 5 in Cursor Settings
Table of Contents
- Introduction
- What is Claude Fable 5 and how does it work in Claude Code?
- How do you enable Claude Fable 5 in Cursor settings?
- Where does Claude Fable 5 earn its 2x cost in coding?
- Where does Claude Fable 5 waste money in daily coding?
- How do you set per-task model rules in Claude Code?
- How do you choose the right Cursor Fable 5 model settings?
- Fable 5 vs Opus 4.8 coding: which model for which task?
- What are the practical caveats of switching to Fable 5?
- Why is your dev team's model spend a real business cost?
- Frequently Asked Questions (FAQs)
Introduction
Anthropic shipped Claude Fable 5 on June 9, 2026, and within a day developers were asking the same question in Slack channels and GitHub threads: should I just switch Claude Code and Cursor over to it and never look back? Fable 5 is the first generally available "Mythos-class" model, built for long-horizon reasoning, autonomous coding, and multi-day agent work. It is also the most expensive Claude yet, listed at $10 per million input tokens and $50 per million output - roughly 2x the price of Claude Opus 4.8 at $5/$25.
That price gap is the whole story. If you flip every keystroke, autocomplete, and one-line fix to Fable 5, you will quietly double your AI bill and get almost nothing extra. But save it for the gnarly stuff - the three-day refactor, the production bug nobody can reproduce, the migration that touches 400 files - and it can pay for itself on the first job it turns from a slog into a solved ticket.
So the honest answer to "claude fable 5 claude code: should I switch?" is: not as a default. Treat it like a senior staff engineer you call in for the hard problems, not the person you ask to rename a variable. This post covers how to enable Claude Fable 5 in Cursor settings, where the Cursor Fable 5 model earns its premium, where it burns money, and how to wire Claude Code and Cursor so the right model runs each task. See the official Claude Fable 5 launch for the full spec sheet.
What is Claude Fable 5 and how does it work in Claude Code?
Claude Fable 5 is Anthropic's most capable generally available model, designed to behave less like a question-answering box and more like a collaborator that can run ambitious, long-running tasks on its own. For coding specifically, three properties matter.
First, it has a 1 million token context window with up to 128K tokens of output. That means it can hold entire modules, tests, tickets, logs, and architecture notes in a single session without constantly dropping context. Second, it ships with always-on adaptive thinking, controlled by an output_config.effort knob. Higher effort tells the model to spend more internal compute on planning, decomposition, and self-checking before it writes code. Third, it is tuned for autonomous, long-running work - in an agent harness it can plan across stages, delegate to sub-agents, and check its own output over hours rather than a single reply.
Inside Claude Code, Fable 5 sits above Opus 4.8 as the top tier. On Claude Code v2.1.170 or later you switch to it with a simple command:
/model fable
There is one quirk to know about: Fable 5 ships with a safety classifier that can reroute some requests back to Opus, occasionally on your very first message. So the model that actually answers may not always be the one you picked. When cost or behavior matters, glance at the model indicator in the UI to confirm what ran.
Anthropic's own guidance is refreshingly blunt: Fable for the hardest, longest work; Opus for everyday; Sonnet for routine; Haiku for quick answers. Everything below is just that hierarchy applied to real coding situations.
How do you enable Claude Fable 5 in Cursor settings?
If your main question is "how do I enable Claude Fable 5 in Cursor settings?", start in Cursor rather than Claude Code. Open Cursor Settings, go to Models, and check whether Claude Fable 5 appears in the Anthropic model list for your account. If it is available, enable it there first, then choose where it should run.
For most developers, the best Cursor Fable 5 setup is not "turn it on everywhere." Use this model split:
| Cursor setting | Recommended default | When to use Claude Fable 5 |
|---|---|---|
| Chat / Agent | Opus 4.8 | Multi-file refactors, deep debugging, long agent tasks |
| Inline edit | Sonnet | Rarely; only for complex local rewrites |
| Autocomplete | Haiku or lightweight model | Almost never |
After enabling the model, test it in a chat or agent session with a small prompt and check the model label before starting paid work. If Claude Fable 5 is not showing in Cursor, the usual causes are account availability, plan access, workspace policy, or an older Cursor build that has not refreshed the model list yet. Update Cursor, reconnect the Anthropic account if needed, and check whether the model is available on your Claude plan before assuming the setting is broken.
The cost-effective rule is simple: set Cursor to a cheaper model by default, then manually switch chat or agent mode to Fable 5 only when the task needs large context, long planning, or higher reasoning. That gives you the upside of Cursor Fable 5 without paying premium-model prices for every autocomplete.
Where does Claude Fable 5 earn its 2x cost in coding?
The useful question is not "is Fable 5 better than Opus 4.8?" For complex, long-horizon work, it usually is. The question is whether the extra capability pays for itself in saved developer time, fewer retries, and less production risk. There are four scenarios where that math almost always works out, and it is worth being specific about them rather than reaching for the premium model by reflex.
When do long multi-file refactors justify fable 5 for coding?
Large refactors and migrations are the textbook case. Think about renaming a core domain concept across hundreds of files, migrating a monolith toward modules, swapping one ORM or HTTP framework for another, or threading multi-tenant logic through a tangled codebase. These jobs punish small context windows because the model keeps forgetting decisions it made a few messages ago and proposes changes that contradict earlier ones.
Fable 5's 1M-token window lets you load a huge slice of the repo at once - key modules, config, representative tests, and a short architecture doc - so it stops backtracking. Combined with its staged planning, you can hand it a goal like "migrate all data access from raw SQL to our new repository layer" and let it analyze current patterns, design the abstractions, and propose phased changes instead of you spoon-feeding one file at a time.
Here the 2x token price is almost irrelevant. If Fable 5 turns a three-day refactor into one day of reviewing and tweaking its patches, a few hundred dollars of tokens is a rounding error next to engineering salaries and the opportunity cost of the work not shipping.
How does Fable 5 handle agentic, long-horizon coding tasks?
Fable 5 is explicitly built for autonomous work that runs longer than any prior Claude. For coding, that maps to giving it a goal and letting it drive rather than dictating each step. Examples that fit well:
- Implement a new feature end to end, including API changes, UI updates, and tests.
- Scaffold a new billing microservice with a data model, endpoints, and integration points.
- Build an internal admin tool with auth, audit logging, and a React frontend from a spec.
With earlier models you often decomposed these into dozens of micro-prompts - "write this file," "now fix the tests you broke." Fable 5's planning and adaptive thinking let you provide a rich goal plus constraints, then spend your time reviewing and course-correcting. In Claude Code, the recommended style is to treat it as a near-equal collaborator: describe the outcome, let it ask clarifying questions in a plan mode, then run a goal loop. This is where Fable 5 changes the shape of your process, not just its speed.
Can Fable 5 crack gnarly cross-cutting debugging?
The third sweet spot is debugging that spans layers - a production-only bug tied to specific data, a race condition across services, a performance regression that only shows under load, or an interaction between config, infra, and application code. These investigations need a lot of disparate evidence held in working memory at once: log excerpts, traces, code from several services, and infrastructure definitions.
Fable 5's large context and self-checking let you dump all of that into one thread, ask it to hypothesize root causes, and refine those hypotheses as you add evidence. The fourth area, large-context reasoning over a whole system, overlaps with all three above: any task where the cost of a wrong or half-finished answer is high, and where holding the full picture in context is the difference between solving it and guessing.
Where does Claude Fable 5 waste money in daily coding?
The flip side matters just as much. Most of what a developer does in a day does not need a frontier model, and routing it to Fable 5 is pure waste. Autocomplete and inline edits are the worst offenders - they fire constantly, and Fable 5's deep reasoning adds latency and cost without improving a single-line completion. The same goes for small functions, boilerplate, scaffolding, simple "explain this snippet" questions, docstrings, and routine test stubs.
For all of these, a cheaper default like Sonnet (or Opus 4.8 for more headroom) does the job at a fraction of the price, and Haiku is fine for the fastest, smallest tasks. The mental model is simple: if a junior engineer could do the task in a few minutes with no deep context, you do not need to call in the staff engineer.
The trap most teams fall into is "it's better, so I'll just use it for everything." Better at the hard 10% does not mean cost-effective for the easy 90% - and defaulting to the premium model for that 90% is where budgets quietly blow up.
How do you set per-task model rules in Claude Code?
The goal is a setup where the cheap model runs by default and Fable 5 only shows up when you deliberately call it. Claude Code supports a default model for the workspace, per-project or per-folder overrides, and manual overrides through commands. That is enough to build a sensible tier.
A practical pattern for most teams looks like this:
- Set a cheaper default - Sonnet, or Opus 4.8 if you want more reasoning headroom - for the workspace. Use it for everyday editing, small functions, boilerplate, tests, docstrings, and code comprehension.
- When you hit a hard, long, or high-risk task, escalate explicitly. Switch the model and, if needed, raise the effort:
/model fable
/effort high
- For agentic work, switch into an auto or goal-driven mode so Fable 5 can plan and loop rather than waiting for step-by-step prompts.
Think of /model fable as paging a senior engineer. You would never do it for every line, but you absolutely would for a tricky migration or a debugging session that has eaten two days. If your team has repeatable heavy workflows - architecture reviews, release-readiness audits - encode them as saved prompts or goal templates that always run on Fable 5, and leave everything else on the default. That keeps the expensive model scoped to the work that earns it.
How do you choose the right Cursor Fable 5 model settings?
Many developers live in Cursor rather than Claude Code, and the same principles apply. The right Cursor Fable 5 model setting depends on the feature. Cursor lets you pick which model powers chat and agent interactions, inline edits, and autocomplete separately, plus project-level overrides. That per-feature control is exactly what you want, because Cursor fires a huge number of small calls for autocomplete and inline edits - the last place you want a premium model.
A cost-aware Cursor configuration usually looks like this:
| Feature | Suggested model | Why |
|---|---|---|
| Chat / Agent | Opus 4.8 default, switch to Fable 5 for complex sessions | Heavy reasoning only when needed |
| Inline edit | Sonnet | Fast, good enough for local edits |
| Autocomplete | Haiku or lightweight model | High volume, latency-sensitive, cheap |
When you do switch Cursor's chat or agent to Fable 5, treat it the way you would in Claude Code: give it a clear goal, let it plan, and reserve it for multi-file refactors, long architectural discussions, deep debugging with large context, or "implement this across the repo" agent tasks. Putting autocomplete on Fable 5 would balloon your bill for no real gain, so the win is in aligning each feature with the right tier rather than picking one Cursor Fable 5 setting for everything.
Fable 5 vs Opus 4.8 coding: which model for which task?
If you want a single reference to point your team at, here is the rough allocation for fable 5 vs Opus 4.8 coding decisions, plus where the cheaper tiers fit.
| Task type | Best model | Reasoning |
|---|---|---|
| Multi-file refactor, codebase migration | Fable 5 | Needs large context and staged planning |
| Long agentic feature build | Fable 5 | Long-horizon autonomy pays off |
| Hard cross-service debugging | Fable 5 | Holds lots of evidence, self-checks |
| Everyday edits, mid-size functions | Opus 4.8 | Strong default without the premium |
| Routine code, tests, docstrings | Sonnet | Cheap and reliable for routine work |
| Autocomplete, quick Q&A | Haiku | Fast and cheapest for volume |
One more detail in Fable 5's favor: it often finishes complex jobs in fewer turns and tokens, so the effective premium on the right workload is smaller than the 2x sticker suggests. Anthropic also offers prompt caching with about a 90% discount on cached input tokens, which helps a lot when you reuse large system prompts or code context. Treat that as an optimization, not a license to default everything to Fable 5.
What are the practical caveats of switching to Fable 5?
Three risks deserve attention before you roll Fable 5 out widely.
Cost creep is real, especially after the free window closes. At launch Fable 5 is free on several Claude plans for a limited rollout, then becomes metered and premium. That trial is great for experimenting, but it also makes it easy to normalize heavy usage patterns that get expensive the moment the meter turns on. In teams, spend often gets skewed by a few power users who default every task to the most expensive model. Guardrails help: set explicit cheap defaults, track usage per model and team, and document in your dev docs exactly when Fable 5 is appropriate.
Sometimes you should not adopt it yet. Very small teams with simple products may find Sonnet and Opus already cover 95% of their needs - better prompts will help more than a Mythos-class model. Teams with a hard budget cap should maximize cheaper models first. And in highly regulated environments, Fable 5's autonomy can increase risk if you do not yet have solid code review, security scanning, and change control. Pilot it on a small set of tasks or repos before making it broadly available.
Output drift happens when you swap models. Even within the same family, Fable 5 may use slightly different coding styles, naming, or default assumptions than you expect. For human-reviewed work this is manageable, but if you have automated anything around LLM output - code generation, test generation, doc bots - a model swap can break tests or violate formatting expectations. Keep tests and linters in the loop, document which model a pipeline assumes, and phase Fable 5 in on reviewed tasks before trusting it in automated flows.
Why is your dev team's model spend a real business cost?
It is tempting to file model spend under "just cloud usage," but for a growing team it is becoming a material operating expense - and the difference between a tiered strategy and "Fable everywhere" can decide whether AI is a net saver or a net cost center.
The right lens is blended cost per unit of work, not raw token price. Fable 5 is 2x Opus per token, but on the right task it uses fewer turns, needs fewer retries, and avoids costly human rework. If it cuts the cycles for a complex job by 40-50%, your cost per completed ticket might be only slightly higher than Opus while your human time drops sharply. Use it for a thousand tiny tasks Opus would have nailed, though, and you have doubled your bill for nothing. Measure cost per completed ticket, feature, or migration - including human time - not per-token rates.
This is really a portfolio allocation problem, the same reason you would not staff every task with your most senior engineer. When you build internal tools or agents, make them model-aware: run most steps on a cheaper model and escalate only specific sub-steps to Fable 5. Choosing that build and model order deliberately is what keeps your AI spend tied to outcomes instead of habit.
If you want help scoping exactly where Fable 5 pays off across your dev workflow and your broader automation stack - and where a cheaper default would serve you just as well - book a 45-minute AI roadmap call. We will map your real tasks to the right model tier so you capture the upside without the runaway bill.
Frequently asked questions
Quick answers on the topics covered in this article.
Open Cursor Settings, go to Models, and enable Claude Fable 5 if it appears for your Anthropic account or plan. Then set per-feature defaults: Haiku or Sonnet for autocomplete, Sonnet for inline edits, Opus 4.8 for chat/agent default, and switch chat or agent mode to Fable 5 manually only for complex sessions like large refactors, migrations, or cross-cutting debug.
No, not as your default. Fable 5 costs about 2x Opus 4.8, and most daily coding - small edits, boilerplate, tests, quick questions - does not benefit from it. Keep a cheaper model as the default in Claude Code and switch to Fable 5 only for hard, long, or high-risk tasks where being wrong is expensive.
Fable 5 is priced at $10 per million input tokens and $50 per million output tokens, roughly double Opus 4.8 at $5/$25. On complex jobs it often uses fewer turns and tokens, so the effective premium can be smaller than 2x, and prompt caching gives about a 90% discount on reused input.
On Claude Code v2.1.170 or later, run /model fable to switch, and optionally raise reasoning with /effort high. Note that a safety classifier can reroute some requests back to Opus, so check the model indicator in the UI to confirm which model actually ran.
In four areas: long multi-file refactors and migrations, agentic long-horizon feature builds, gnarly cross-cutting debugging, and large-context reasoning over a whole system. These tasks reward its 1M-token context and staged planning, and the token cost is trivial next to the human time it saves.
On autocomplete, inline edits, small functions, boilerplate, scaffolding, docstrings, and simple Q&A. These high-volume, low-context tasks run fine on Sonnet or Haiku. Routing them to Fable 5 adds cost and latency with no real quality gain.
First update Cursor and refresh the Models settings page. If Fable 5 still does not appear, check whether your Claude or Anthropic account has access, whether your workspace policy blocks the model, and whether Cursor has refreshed the latest Anthropic model list. Until it appears, use Opus 4.8 for chat/agent work and keep the same tiered setup.
Use Cursor's per-feature model settings: a cheaper model for autocomplete, Sonnet for inline edits, and Opus 4.8 as the chat/agent default with a manual switch to Fable 5 for clearly complex sessions. Cursor fires many small calls, so keeping autocomplete off the premium model matters most.
For complex, long-horizon work, generally yes. For everyday edits and routine tasks, the difference rarely justifies the price. The right question is not which is better overall but which pays for itself on a given task type.
Track blended cost per completed ticket, feature, or migration - including human time - rather than per-token price. If Fable 5 cuts cycles and rework enough that cost per finished unit of work drops or barely rises, it is worth it. If it just doubles your bill on tasks Opus handled fine, it is not.
Share this article
Related workflows
