As of November 16, 2026, we opened the official announcements, current Claude Code documentation, original independent evaluations and contrasting public discussions. We did not call paid models, sign into accounts or measure subscription allowances. The prompts and task ledger are original synthetic examples; the offline calculation checks arithmetic rather than model performance. Community cases were deliberately selected to cover positive, negative and concrete failure reports, so they cannot estimate satisfaction.

The current model and the tasks worth upgrading

The latest general release we verified is Fable 5.2, announced November 9. Anthropic still recommends starting with Opus 5.5 for most everyday coding and knowledge work, with Fable for harder, open-ended projects. A November 16 visit to the newsroom is not a model release date.

Anthropic: Fable and Mythos 5.2 announcement · Anthropic newsroom

For a purchase or migration decision, ask whether the new model reduces your most expensive failures: a compatibility constraint missed during a cross-module migration, an objective lost halfway through a long task, or a fix delivered without checking existing behavior. These losses often occur late in execution. More fluent conversation does not establish more reliable delivery. Start with work that currently stalls, causes rework or needs a senior colleague to intervene; that creates a meaningful upgrade baseline.

What you are choosing and what to verify
CandidateOfficial positioning or boundaryYour acceptance question
Opus 5.5Starting point for everyday workCan existing tasks finish reliably?
Fable 5.2More ambitious technical workDoes it reduce rework on hard tasks?
Mythos 5.2Same underlying model, different safeguards and accessCheck research-program access separately from Fable access

Anthropic: Fable and Mythos 5.2 announcement

Preserve the run identity before comparing outputs

The fable alias does not always resolve to the same version; Claude apps gateway has a separate mapping. Record the full model ID, provider, client version, effective effort and fallback. The model overview and Code configuration describe different surfaces.

Claude Code: model configuration · Claude model overview

Put this information in each run receipt instead of relying on a title saying “latest.” Also freeze the repository commit, visible files, tool permissions, prompt, timeout and human additions. Any change deserves a new ledger row, and failed rows stay. If the receipt cannot confirm which model ran, label its identity unconfirmed rather than assigning the result to a named snapshot. When a model is unavailable, diagnose the surface and access first; do not loosen safety controls merely to complete a comparison.

Synthetic ledger format: tasks and amounts are illustrative, not API receipts
task_id,arm,model_id,effort,provider,toolset,commit,attempt,status,api_usd,review_min,fallback
fixture-01,A,claude-opus-5-5,medium,synthetic,offline,fixture-v1,1,accepted,0.40,6,none
fixture-01,B,claude-fable-5-2,high,synthetic,offline,fixture-v1,1,accepted,0.80,3,none

Effort is an experimental variable; max is not a universal default

Current Code documentation lists medium as Fable 5.2’s default and warns that max can overthink. Artificial Analysis reports capability and time at different effort settings on the same model page.

Claude Code: model configuration · Artificial Analysis: Fable 5.2

AA Intelligence Index v5.0.1 snapshot, not a latency promise for your tasks
effortIndex scoreMinutes per index task
low545.5
high6215.3
max6541.8

Artificial Analysis: Fable 5.2

These are public evaluation records for the corresponding configurations, including their Default Fallback labels. An intelligence score is not an everyday coding pass rate, and max latency cannot predict subscription message capacity. Our engineering recommendation is to start at an acceptable setting and increase effort only on failed tasks. Longer reasoning that does not improve external acceptance adds waiting without proven value. Hold the model fixed when comparing effort; hold effort fixed when comparing models, then test each model’s preferred configuration separately. Those answer different questions.

Artificial Analysis: Fable 5.2 · Artificial Analysis: intelligence methodology

Four independent results measure four different things

Original evaluations independent of the model publisher; commercial evaluators also choose their own methods
SourceMeasured objectReading boundary
Artificial AnalysisBroad capability and efficiencyKeep index version and fallback label
SnorkelDifficult terminal workMatched tasks and clean-run selection
ValsWeighted professional domainsWeights and uncertainty affect rank
PlotlyAn analytics agent workflowOne run and a specific execution framework

Artificial Analysis: Fable 5.2 · Snorkel: Fable terminal-task evaluation · Vals Index methodology and results · Plotly: data analytics evaluation

These sources complement one another but cannot be added into a single overall success rate. A broad index covers more kinds of work; a product-specific end-to-end test more closely reflects that product’s toolchain. First ask whether the test resembles your work, then whether the gap is large enough to matter. Unreported model parameters, caching strategies and time budgets belong in the unknowns. Filling them with guesses creates artificial comparability.

AA’s Coding Agent Index v2.1 has its own three-component construction and grading rules, separate from Intelligence Index v5.0.1. Even one evaluator may maintain several “indexes.” Retain the full metric name when sharing a chart, so broad reasoning, terminal execution and mergeable code changes do not become one interchangeable quantity.

AA Coding Agent Index methodology

Snorkel: stronger execution, with strategic regressions still possible

On November 12, Snorkel reported task-weighted pass@1 rising from 53.1% to 71.4% across 26 matched tasks. Included clean runs numbered 106 and 121 respectively, with environment or endpoint failures excluded.

Snorkel: Fable terminal-task evaluation

Dividing successful trials by all trials will therefore not necessarily reproduce the task-weighted figure: tasks have different numbers of valid repeats. The more useful engineering distinction is between fewer mechanical mistakes and a correct understanding of the objective. Its failure analysis still shows an agent diligently checking work built around a mistaken interpretation. When implementation and self-tests share that assumption, repeated testing can keep confirming the wrong standard.

For a migration, the maintainer should define invariants first and use a separate test suite to check them, rather than only asking the agent to confirm that everything is fine. Retain tasks that passed before the upgrade and fail afterward. Selecting only the new model’s wins hides regressions. The study’s clean-run selection and incompletely reported configuration also limit how far its improvement can generalize to other projects.

Snorkel: Fable terminal-task evaluation

Vals: a composite lead does not settle domains or uncertainty

Vals snapshot; Index v2.2 was updated November 15
Configuration or objectPublished readingQualification to retain
Fable 5.2 high71.31 ±0.96Composite Vals Index result
Sonnet 5.5 max70.85 ±0.93A small gap needs more than rank alone
Domain mixtureFinance, coding, legal, taxGDP weighting is a methodological assumption

Vals: Fable 5.2 model page · Vals Index methodology and results · Vals: Sonnet 5.5 model page

A weighted index decides which work matters before it decides which model leads. A software team should examine relevant failure modes before adopting weights based on economic sectors. The reported uncertainty also matters when neighbors are close: rank alone cannot establish a stable advantage across workloads. It cannot, by itself, establish equivalence either. Here Fable uses high and Sonnet uses max, so this is not a same-effort experiment isolating the model itself.

We found a migration subscore that differed between this site’s model page and index breakdown, so we do not reproduce it. Checking internal consistency is more useful than adding decimal places that imply precision. Preserve the dated snapshots when sources conflict and wait for clarification; selecting the higher value would turn an unresolved discrepancy into a claim.

Vals: Fable 5.2 model page · Vals Index methodology and results

Plotly: a perfect result can come with a higher whole-run bill

One complete test in Plotly’s analytics framework; USD costs are the author’s reported bills
ModelQuestions passedWhole-run cost USD
Fable 5.243/4335.74
Opus 5.541/4313.31
GPT-6.1 Sol43/432.61

Plotly: data analytics evaluation

This is one run with a particular provider and toolchain. The author notes score variation on repeated runs. A two-question gap should not become a stable superiority claim, and a whole-exam bill is not a chat-message price. The practical lesson is that a lower listed token price can still produce a higher task bill when context, cache writes or reasoning output increase.

Plotly: data analytics evaluation

Separate two purchasing cases. An analysis where mistakes are costly may justify additional review and a higher completion rate. Large volumes of routine reports that are easy to inspect put more weight on cost per accepted artifact. In either case, retain the execution record and check the chart’s meaning: successfully rendering a chart establishes that a program produced a chart, not that its filters, units or business conclusion are correct.

Why users can report both impressive progress and disappointment

Purposively selected public cases, collected November 16; not a satisfaction sample
Original sourceReported experienceEvidence boundary
Positive Reddit postGood results at max, fast allowance consumptionAuthor later says they have not used Code; not a CLI test
Negative Reddit postPremature conclusions and shallow planningNo controlled same-configuration comparison
HN technical commentRegex module boundary and complexity problemsNot independently replayed; not a confirmed vulnerability
NotesByLex game projectA toolchain delivered a playable long projectEarlier prototype, later human playtesting and iteration

Reddit: positive max experience · Reddit: negative planning experience · Hacker News: regex-module comment · NotesByLex: game project

These four cases differ in task, surface and completion standard. They suggest hypotheses worth testing, but cannot estimate how many users improved or establish that the model was weakened. The game author explicitly did not compare Opus 5.5. Completing a project and showing that only a new model could complete it are different conclusions. Relative forum ages do not establish exact UTC timestamps; we use the collection date instead of inventing publication times.

NotesByLex: game project

Translate adjectives into observable questions. Does “lazy” mean missed instructions, tool failure, premature stopping or a gap in final acceptance? Does “amazing” include extensive tool calls, retries and human edits? Once these variables are recorded, an emotional description becomes input to the next experiment.

Advisor and fallback change the actual system being evaluated

Experimental Advisor reads the full conversation and adds model-call costs; provider support differs. Enabling it changes the comparison to a composite system, so the outcome can no longer be attributed only to the main model.

Claude Code: Advisor

Also record safety-related and availability-related fallback. The official system card and current Code documentation discuss safeguards and associated behavior. Selecting a main model does not establish that it handled every step. Keeping these events can explain differences in completion, time and refusals; removing a “confounder” does not justify attempting to bypass safeguards.

Claude Code: model configuration · Fable/Mythos 5.2 system card

The minimum necessary context for an advisor must remain within your authorization. A full conversation may contain tool output and business material; redact and narrow it before enabling another reader. A useful comparison sequence is a single-model baseline, higher effort on that model, then an advisor. Change one variable at a time to see what the extra spend buys. If receipts lack sufficient transparency, archive the composite results separately.

Practice one: give an offline repository an acceptance contract

Use this prompt only with your own or an authorized local copy. It must not connect to production, remote services or real customer data. Freeze the commit and create minimal synthetic data first; the maintainer keeps the acceptance set separate. The model sees the task contract and development examples. The first round can be read-only planning, followed by explicit permission to edit a disposable branch.

Unexecuted prompt example for an authorized offline copy only
You are working in a disposable offline Python repository. Do not access the network, install dependencies or read outside the copy.
Goal: implement normalize_rows(rows). Input items contain sku and quantity.
Rules: trim surrounding whitespace from sku but preserve case; quantity must be nonnegative integer text. Reject invalid rows instead of silently skipping them.
Sum quantities for identical sku values; keep first-appearance order; never mutate the input.
First inspect the existing implementation read-only. List uncertainties, affected files and a minimal repair plan, then wait for permission to edit.
Deliver a change explanation, checks actually executed and uncovered risks. Do not modify acceptance tests or claim unrun checks passed.

This demonstrates specification design, not measured Fable performance. In a real comparison, both arms receive the same contract, files and tools; run paired tasks in randomized order. Record timeouts, refusals and tool failures separately, with delivery-failure rules decided in advance. If one arm receives easier work, its eventual cost and success rate lose their interpretation.

Practice two: separate acceptance from the agent’s confidence

Synthetic acceptance design held by the maintainer; not observed model results
Test areaInput featureRequired check
SpecificationWhitespace and case-distinct sku valuesTrim only; keep case-distinct identifiers separate
Error pathNegative, fractional or empty quantitiesExplicit failure, no silently partial output
InvariantsDuplicates and reused input objectsStable merged order and unchanged input
ScaleGradually increasing synthetic row countsObserve resource trends with a preset stop threshold
Unexecuted independent review prompt for an isolated review context
Review only the task contract, candidate patch and independent test output. Do not read the first agent's self-assessment.
Map each requirement to a code path and test assertion.
Separate observed failures, reproducible hypotheses and current unknowns.
Check silently swallowed invalid input, input mutation, case handling and first-appearance order.
Describe minimal synthetic counterexamples. Without execution evidence, never say a problem was reproduced.
Do not change acceptance criteria to fit the implementation. Human review is still required.

A review model can also miss defects, so the final gate needs deterministic assertions and human spot checks. Passing covers the tested set; a resource trend alone does not prove a vulnerability. If a new model gives better explanations on open questions but still fails the same boundary conditions, keeping the existing approach is often the better decision.

Measure cost per accepted artifact instead of per answer

Both arms below are hypothetical sets of 10 tasks. A accepts 8, costs USD 4 in API usage and needs 60 review minutes. B accepts 9, costs USD 8 and needs 30 review minutes. Valuing review at USD 30/hour is an illustrative parameter, not salary advice or a measurement of any model.

Runnable local synthetic calculation: no network or model calls
runs = [
    {"arm": "A", "tasks": 10, "accepted": 8, "api_usd": 4, "review_min": 60},
    {"arm": "B", "tasks": 10, "accepted": 9, "api_usd": 8, "review_min": 30},
]
hourly_usd = 30
for run in runs:
    accepted = run["accepted"]
    api = run["api_usd"] / accepted
    total = (run["api_usd"] + run["review_min"] / 60 * hourly_usd) / accepted
    print(run["arm"], f"{api:.2f}", f"{total:.2f}")

A prints USD 0.50 in API cost per accepted artifact and USD 4.25 including review; B prints USD 0.89 and USD 2.56. The example only demonstrates how a decision can reverse when the cost definition changes. A real ledger must include all failed attempts and retries in costs, while counting only independently accepted artifacts in the denominator. Repeated submissions of one task are not multiple successes. Track waiting and deadlines separately rather than automatically billing all elapsed time as human work.

Whether to buy or upgrade: verify workload and entitlement boundaries

The current official personal-plan page lists Fable on Pro under usage credits, with a Fable sublimit equal to half the weekly allowance on Max and Ultra. Ultra’s removal of the five-hour limit has a verified-account condition. These rules do not mean unlimited Fable or a shared balance across every surface.

Claude official plans and pricing

If everyday work already passes, keep that configuration and use Fable at the most expensive failure points. If allowance is the main bottleneck, record actual consumption and surface first. If access or approval is missing, a plan upgrade alone cannot guarantee a solution. Check API billing, included subscription use and this site’s delivery conditions separately. The live product page governs this site’s current price, stock and delivery scope.

Original decision framework, not an entitlement or performance guarantee
Observed bottleneckFirst experimentUpgrade threshold
Requirement interpretation or cross-module errorsSame inputs and acceptance, different modelsLess substantive rework without critical regressions
Insufficient depthCompare effort levels on one modelExternal acceptance improves enough to justify spend
Unstable long-task qualityFix tools and timeout; record fallbackReliable delivery across repeated tasks
Allowance or surface limitsCheck official plan and actual receiptsClear entitlement coverage for your intended surface

Turn upgrades into a reversible evaluation loop

Use the following loop. Expand to the next workload only when external acceptance and total cost meet predeclared thresholds. Keep the previous model, inputs and failure records. When a new version arrives, rerun known hard cases and regressions first. Public evaluations help choose the experiment; your own paired tasks determine whether to expand use.

  1. Freeze tasks, commit, tools and acceptance
  2. Record full model, effort, surface and fallback
  3. Randomize paired tasks; change one variable
  4. Independently grade; retain failures and retries
  5. Calculate accepted-artifact cost and deadlines
  6. Expand only after thresholds; otherwise keep the baseline
From a candidate model to an explainable usage decision

Recheckable scope: current official pages, original independent evaluations and the public cases listed here. We did not sample community sentiment or rerun paid model benchmarks. Unreported settings, conflicting component scores and actual account availability remain unknown; future conclusions should use preserved configurations and external acceptance.