llm-anthropic 0.31 Adds Fable 5.2, With a Reasoning Budget Caveat
Simon Willison released llm-anthropic 0.31 on November 9, adding Anthropic’s latest models while reporting a failure at the highest reasoning setting. His drawing experiment produced a result he preferred at xhigh, but exhausted its token allowance at max. That contrast gives developers something more useful than another model announcement: a concrete reason to test reasoning settings before choosing defaults.
The release connects Fable 5.2 and Mythos 5.2 to LLM, a tool for accessing language models from a terminal. The central tension is between additional computation and completed work. More time spent reasoning does not automatically produce a usable answer.
For developers evaluating the update, access and reliability are separate questions. The integration makes experimentation easier, but teams still need evidence that their chosen configuration finishes the actual assignment. A leading benchmark position and an unsuccessful drawing request can coexist without either observation canceling the other.
What llm-anthropic 0.31 Actually Changes
The release adds access to new models through an existing developer interface; it does not establish their performance across production tasks.
The project’s model support release lists claude-fable-5.2 and claude-mythos-5.2. These are the names exposed through the plugin, an extension that connects LLM to Anthropic’s service. The change gives existing users a familiar place to evaluate the new models.
The package release record independently dates version 0.31 to November 9, 2026. This matters because the article concerns a specific integration release, rather than a general promise of future support. Readers can distinguish the software update from the model launch surrounding it.
That distinction also separates responsibility. The plugin handles an integration layer, while the hosted model supplies the response. A disappointing output does not, by itself, identify which layer caused the problem. Diagnosis requires information about the request, configuration, response, and stopping condition.
For existing LLM users, continuity is the immediate benefit. They can investigate a new model without rebuilding their entire evaluation workflow around another interface. Keeping the surrounding process familiar can make differences in model behavior easier to notice.
However, familiarity should not be confused with identical behavior. A model substitution can change answer length, completion time, and the usefulness of a reasoning setting. An unchanged prompt does not guarantee an unchanged operational experience.
This creates an important distinction between compatibility and suitability. Compatibility asks whether a request reaches the intended model and returns a response. Suitability asks whether that response satisfies the task under acceptable constraints. A release can improve compatibility while leaving suitability open for investigation.
The update therefore deserves a narrower reading than “the newest model is now the best default.” It establishes an entry point for evaluation. The decision to adopt a model across a workflow remains separate.
Consider a developer who generates diagrams during documentation work. Successfully selecting the new model would confirm access. Receiving valid drawing code would confirm a further requirement. Producing a clear diagram before a review deadline would establish something closer to practical usefulness.
Those checkpoints belong to the same workflow, but they answer different questions. Treating them as interchangeable makes release coverage sound more conclusive than the evidence supports. It also makes failures harder to classify when teams begin testing.
The news value of llm-anthropic 0.31 lies in shortening the distance between announcement and observation. Developers can move from reading model claims to examining outputs through a tool they already use. That access is useful precisely because it allows assumptions to be tested.
A Pelican Drawing Exposes the Completion Problem
An unfinished answer is a meaningful outcome, even when the model spends substantial computation trying to produce it.
In his reasoning effort comparison, Willison requested an SVG of a pelican riding a bicycle. SVG, a text format describing vector graphics, makes the result inspectable as both code and a rendered picture. The request gives an abstract model evaluation a visible endpoint.
He tried five reasoning settings: low, medium, high, xhigh, and max. Willison identified xhigh as his best result. He reported that max exhausted its allowance after spending 128,000 tokens on thinking, without returning the requested image.
Tokens are the units a language model processes and generates. Their consumption measures activity, but activity is not the same as completion. For the person awaiting a drawing, the essential question is whether a usable artifact arrives.
The observation supports a limited conclusion. In this reported experiment, the highest effort setting did not deliver the requested result. It does not establish how frequently that happens, whether another request would behave similarly, or which component caused the exhaustion.
Still, a limited observation can expose an important evaluation gap. A workflow that records only the quality of completed answers would miss requests that never reach that stage. Excluding those requests would make the successful outputs look more representative than they are.
A drawing prompt also creates a helpful distinction between aesthetic preference and operational failure. Choosing the better picture involves judgment. Recording that no picture arrived concerns task completion. Those outcomes deserve separate treatment, even when they arise in the same experiment.
This distinction becomes sharper in automated work. A person can recognize that a request failed and change the setting. An unattended process needs an explicit response to the same condition. Otherwise, the failure can leave downstream work waiting for an artifact that does not exist.
For example, imagine a documentation pipeline expecting drawing code before assembling a page. A visually imperfect drawing might still enter review. An absent drawing requires a different action, such as stopping publication or requesting another attempt. These are hypothetical consequences, not outcomes demonstrated by Willison’s test.
The pelican example should therefore be understood as a diagnostic clue rather than a comprehensive verdict. Its value comes from making completion visible. The prompt asks for a concrete deliverable, allowing readers to distinguish extended effort from a finished response.
That is also why the result deserves attention beyond image-like tasks. The same evaluation question applies whenever a model must produce something another process can use. A draft, a code change, and a structured report all need a recognizable endpoint.
Developers Now Have to Choose What “Better” Means
The teams under immediate pressure are those choosing model defaults, because they must balance answer quality against dependable completion.
A model developer can describe improvements across a range of evaluations. An application team has a narrower obligation: deliver the expected result for its users. Those responsibilities overlap, but they do not produce identical definitions of success.
For a developer tool, better might mean fewer incorrect edits. For a document assistant, it might mean clearer explanations supported by the supplied material. For a background process, it might mean finishing without intervention. A single effort setting cannot be assumed to optimize every objective.
The llm-anthropic update makes this decision more accessible, but also harder to avoid. Once a model becomes easy to invoke, teams need a position on where it belongs. Availability creates a practical choice about adoption rather than settling that choice.
The most tempting shortcut is to associate the highest setting with the highest quality. That shortcut is understandable because the labels suggest an ordered scale. However, an ordered scale of effort does not establish an ordered scale of usefulness for every request.
The relevant opponent here is maximum effort versus reliable delivery under a budget. That budget can include waiting time, token consumption, and reviewer attention. These constraints remain meaningful even when an organization is willing to devote substantial resources to difficult work.
Reasoning effort comparison should therefore focus on the whole result. A useful comparison includes successful completion, answer quality, and the resources consumed. Measuring only the most flattering dimension can hide the reason a configuration disappoints users.
This changes how teams should interpret demonstrations. An impressive finished artifact shows that a particular result was possible under particular conditions. It does not reveal how many unsuccessful attempts preceded it unless those attempts are documented.
The reverse also applies. An unsuccessful artifact request should not erase successful results elsewhere. Responsible evaluation preserves both categories rather than searching for a single example that settles the model’s reputation.
For enterprise buyers, the operational question concerns accountability. Someone must decide when an answer is acceptable, when a request has failed, and when another attempt is justified. A model’s reputation cannot make those decisions on the organization’s behalf.
Knowledge workers face a related problem when comparing outputs informally. If they save only the preferred response, they lose the context needed to understand why it worked. Recording the model, setting, prompt, and outcome makes later comparisons more useful.
Teams organizing such material can connect it with a searchable knowledge base. The purpose is to retain the evidence behind adoption decisions, including unsuccessful runs. A collection of polished examples alone cannot show how dependable a workflow has become.
The immediate consequence is a shift in evaluation ownership. Integration maintainers provide access, and model providers describe capabilities. Application teams still own the final judgment about whether a configuration serves their users.
Benchmark Leadership Answers a Different Question
Independent benchmark results provide useful evidence, but they do not guarantee that every request will finish or that maximum effort suits every workflow.
The model intelligence index page from Artificial Analysis places Fable 5.2 first among 81 models in its displayed intelligence summary. The listed configuration is “Max, Default Fallback.” That configuration detail belongs alongside the ranking when readers interpret the result.
Artificial Analysis also reports a time per intelligence-index task of 41.8 minutes for the model. This is a measurement within its evaluation framework. It should not be presented as the expected duration of an arbitrary terminal prompt.
Together, the ranking and timing illustrate why capability and responsiveness deserve separate attention. A model can perform well on a demanding evaluation while taking substantial time to complete the evaluated work. Whether that tradeoff is acceptable depends on the application.
The benchmark result does not contradict the pelican observation. They concern different tasks, evaluation conditions, and outcomes. Treating either as a universal answer would flatten the evidence rather than clarify it.
A benchmark asks how a system performs under a defined measurement process. A developer evaluating an application asks whether the system meets that application’s requirements. Strong benchmark performance can justify testing, but it cannot replace the application test.
This distinction becomes important when comparing Anthropic with other providers. A fair comparison should use the same task requirements and disclose relevant settings. Otherwise, the apparent winner can reflect differences in evaluation conditions rather than a useful advantage for the reader.
The same principle applies within a provider’s lineup. Comparing Fable with Opus requires more than matching model names to a ranking. Teams need to establish whether the additional effort produces a result they value on their own workload.
Anthropic’s model launch details position Fable and Mythos for demanding technical work. The company recommends starting with Opus 5.5 for most coding and knowledge tasks. Its own positioning therefore leaves room for model selection rather than a universal upgrade path.
That recommendation is useful context because launch coverage often compresses a product lineup into a race for the strongest model. Actual deployment decisions involve a more specific question: which model should handle this assignment?
A hypothetical engineering team evaluating difficult debugging requests might reasonably accept a longer wait for a more accurate diagnosis. The same team might reject that delay for routine formatting. Those judgments reflect different task requirements, not inconsistent attitudes toward model quality.
The practical conclusion is to keep benchmark evidence in its proper role. It helps identify capabilities worth investigating and configurations worth comparing. It does not remove the need to measure completion, inspect outputs, and account for the surrounding workflow.
The Evidence Does Not Establish a General Failure Rate
The skeptical reading should challenge broad conclusions in both directions: neither a launch claim nor an isolated failure establishes overall reliability.
The available evidence leaves several questions unanswered. It does not establish the frequency of token exhaustion across representative workloads. It also does not isolate whether the reported behavior depends on the prompt, request settings, model behavior, or their interaction.
No independent tests were performed for this article. The reported drawing outcome remains Willison’s observation, supported by his published account. The analysis here concerns its implications for evaluation, rather than a new measurement of Fable’s behavior.
That boundary matters because vivid examples are unusually persuasive. A failed pelican drawing is easy to remember and share. Its visibility does not make it statistically representative, just as an impressive demonstration does not establish a general success rate.
A careful assessment would preserve unsuccessful attempts and classify their causes. A request that reaches its token limit differs from a service interruption. A completed but incorrect answer differs from an answer that violates the required format. Combining those outcomes would obscure useful information.
The same care applies to the word “reasoning.” Users observe configured effort, resource consumption, and outputs. They should avoid treating a longer internal process as direct proof of deeper understanding or a more dependable result.
Anthropic’s broader launch claims also require attribution. The company says the models contributed to solving open problems in black-hole physics. This article has not independently verified those scientific results, and the claim does not validate unrelated drawing or coding workflows.
Scientific work requires evidence appropriate to the scientific claim. Application reliability requires evidence appropriate to the application. Connecting them through a shared model name does not eliminate the difference between those standards.
Access is another distinct issue. Anthropic describes Fable and Mythos as sharing an underlying model, with different safeguards and access conditions. Support for a model name in an integration does not imply that every user is authorized to access it.
That distinction prevents another misleading inference: a plugin listing is not a promise of universal availability. Developers evaluating the release need to separate successful installation from access granted by the service. A rejected request can reflect eligibility rather than model quality.
There is also a risk of responding to the pelican example too aggressively. Automatically reducing effort after every slow request might improve completion for some assignments while undermining others. The appropriate policy requires evidence from the tasks the system actually handles.
The strongest conclusion remains deliberately bounded. The report identifies a failure mode worth investigating and a reason to avoid untested assumptions about maximum effort. It does not establish that high effort is generally ineffective or that the integration itself is defective.
What to Watch After the Integration Release
The next useful evidence will show whether the behavior repeats, whether changes address it, and whether higher effort improves real work enough to justify its demands.
The first signal is reproducibility across effort settings. Over the coming months, published comparisons would be more informative if they retained prompts, configurations, stopping conditions, and unsuccessful attempts. That information would help readers distinguish repeatable behavior from an unusual run.
If comparable requests repeatedly exhaust their allowance at maximum effort, the case for selective use would strengthen. If repeated evaluations complete successfully, the original observation would deserve a narrower interpretation. Either outcome would improve the evidence available for configuration decisions.
Reproduction should also preserve what the task requires. A drawing evaluation needs a usable drawing, while a code evaluation needs an appropriate code result. Changing the success criterion after seeing the output would make comparisons less trustworthy.
The second signal is a documented change connected to the observed behavior. Future plugin releases, service updates, or technical explanations could clarify relevant settings and stopping conditions. A useful update would explain what changed and show the effect on comparable requests.
A claimed fix would become more persuasive if it preserved successful results while reducing incomplete responses. An unexplained improvement would still be welcome, but it would offer less guidance for teams deciding how broadly to deploy it. Documentation matters because adoption depends on understanding the conditions.
The third signal is task-specific evidence from practical deployments. Teams should watch for evaluations that report completion and human review alongside answer quality. A favorable result would show that additional effort improves accepted work under constraints the evaluator clearly describes.
If the highest setting repeatedly produces better accepted outputs, that would support using it for the relevant task category. If a lower setting performs similarly with fewer unfinished requests, that would support a different default. The conclusion should follow the workload rather than the label.
These signals also provide a fair basis for comparing models from competing providers. The question is whether a system delivers the required result under disclosed conditions. Brand preference and launch momentum are weaker substitutes for that evidence.
For now, llm-anthropic 0.31 is a concrete integration update with an instructive evaluation caveat. It makes the new models available through a familiar interface while leaving their best operational role open to testing. That combination is useful without requiring either celebration or dismissal.
Before expanding an existing workflow, choose a representative task and define what successful completion means. Compare available effort settings, retain failed attempts, and inspect the finished artifacts against the same requirements. Record enough context that another reviewer can understand why a configuration earned its place. Keep difficult cases alongside routine work so an attractive average does not hide an important weakness. Use llm-anthropic 0.31 as an opportunity to collect that evidence, then choose the model and effort level that deliver the work your users actually need.



