llm-anthropic 0.31 Adds Support for Claude Fable 5.2 and Mythos 5.2

Anthropic has released two new models, Fable 5.2 and Mythos 5.2, and Simon Willison promptly wired them into his llm-anthropic plugin, bumping the version to 0.31. For developers who are used to interacting with LLMs from the command line, this is a nearly zero-latency model launch—the moment Anthropic's official announcement landed, the plugin was already able to call the new models.

Getting the new models running in two commands

llm-anthropic is the Anthropic model provider plugin within the llm ecosystem. After upgrading to 0.31, the full call chain can be completed in a single terminal session: install llm, install the plugin, set the Anthropic API key, and then send a prompt straight to Fable 5.2.

uv tool install llm
llm install llm-anthropic
llm keys set anthropic

`llm` is a command-line tool developed by Simon Willison for interacting with various LLMs in the terminal. It is not tied to any single model vendor; instead, it extends via a plugin mechanism: each plugin handles integration with one vendor's API and registers that vendor's model list. `llm-anthropic` is one such provider plugin. After installing the plugin, `llm models` lists the available Anthropic models, and the `-m` argument specifies a particular model. API keys are managed centrally via `llm keys set` and stored in a local config file, so they never appear in command history or a code repository. This design keeps model switching entirely at the command-line level, with no code changes required.
# paste key here
llm -m claude-fable-5.2 "Generate an SVG of a pelican riding a bicycle"

This rhythm of "vendor ships a model, plugin follows with a version bump, user swaps a parameter" is the core value of tools like llm. It downgrades model selection from a code change to a command-line argument swap, and lets new models from different vendors be quickly compared side by side under a unified interface.

The pelican test across five reasoning levels

Simon stuck with the benchmark he has long used—asking the model to generate an SVG of "a pelican riding a bicycle." This time he ran through all five reasoning levels for Fable 5.2: low, medium, high, xhigh, and max.

The outputs from all levels are collected on a single rendering page for level-by-level comparison. The best result came from xhigh: the bicycle legs are on the correct side of the frame, the frame structure is intact, and the pouch of the beak is drawn reasonably well—though the pouch and the top of the beak are slightly misaligned, and a few oddly shaped little fingers appear on the handlebars.

This prompt is used repeatedly because it tests several things at once: whether the model can understand a spatial relationship like "riding," whether it can express complex structures using vector graphics syntax, and whether it can maintain enough shape consistency within a single output. Plain-text descriptions can get away with vagueness; SVG cannot—if it's drawn wrong, it's wrong.

Reasoning effort is a control parameter introduced by reasoning models in recent years; essentially, it specifies in the request an upper bound on the token budget the model may spend on internal thinking. The higher the level, the more reasoning steps the model is allowed to take before producing its final answer, but response latency and token consumption increase accordingly. Vendors do not agree on the naming or granularity of these levels, and the five levels from low to max offered by Fable 5.2 are a relatively fine-grained division. Note that a level is only a budget cap; it does not guarantee that the model will allocate that budget sensibly—when the thinking process fails to converge, the model may keep reasoning until it exhausts the quota, causing the final output to be truncated or missing entirely.

The 128,000-token predicament of the max level

The one that truly warrants caution among the five levels is max: it did not return an image at all. The model consumed 128,000 tokens during the thinking phase, then ran out of quota, producing not a single image.

This is not the first time. Simon had previously seen the same failure mode on Opus 5.5—the higher the reasoning level, the more likely the model is to lose control over the act of "thinking" until it burns through the output budget. But for the Fable series this is a new problem: both Fable 5 and Fable 5.1 returned the pelican normally at the max level.

In other words, Fable 5.2 may have improved in reasoning capability, but budget control at high reasoning levels has regressed. For users who treat max as the "safest option," it is in fact the least safe level.

SVG (Scalable Vector Graphics) is an XML-based 2D graphics description format that defines shapes using elements such as <path>, <circle>, and <rect> along with coordinates and Bézier curve parameters. Unlike raster images, SVG correctness can be checked directly: the position, size, and stacking relationship of every shape are written in the text, so any error in spatial relationships is obvious in the rendered result. This is exactly why "a pelican riding a bicycle" makes an effective benchmark—it requires the model to handle the relative positions of the figure and the object, the connections between limbs, and overall structural integrity all at once, and none of these can be glossed over in SVG syntax. By contrast, when describing the same scene in plain text, a model can use vague wording to mask flaws in its spatial understanding.

Engineering lessons from reasoning levels

Two takeaways emerge from this test. For model vendors, a reasoning level should not just be "an upper bound on the thinking budget"; there also needs to be a reliable fallback mechanism—when thinking exhausts the budget, the model should at least return a partial result or an explicit error, rather than failing silently.

For users, a high reasoning level does not equal high-quality output. xhigh produced the best pelican of this run, while max produced an empty result. When integrating such models into production workflows, level selection should be based on actual testing rather than intuition, and a degradation path should be reserved for "no output." The release of llm-anthropic 0.31 is lightweight in itself, but the reasoning-budget problem it incidentally exposes is worth factoring into model selection.