Claude Fable 5.2 Paints Images Stroke by Stroke Through Code
- Gate
- Machine Learning
- Departs
- Crew
- Manuel Uth
- Passengers
- 676
Anthropic's Fable 5.2 builds images by placing simulated brushstrokes through Python code, with no undo, and trails OpenAI's GPT-6 Astra in a physical robot test.

Fable 5.2 doesn't render images the way most image models do. It writes a program that paints them, one simulated brushstroke at a time, and the results are more than a novelty.

Most current image generators, Midjourney among them, rely on diffusion. The model starts with noise and gradually refines it into a picture. Fable 5.2 skips that step entirely. It simulates the act of painting: bristle texture, how paint lays down on canvas, and the mistakes a painter has to fix afterward. The output is a sequence of decisions rather than a denoising pass, and that changes what you can inspect, edit and argue with.
Developer Jake Eaton, who works at Anthropic on research into model values, safety mechanisms and agent behavior, has been showing what the approach can do. When he asked Fable 5.2 for a painting that would be hard to tell apart from a photograph, the model produced a parking garage scene with a shopping cart and harsh sunlight across the wall. It took roughly 700,000 simulated brushstrokes.
What the pipeline actually looks like
Eaton says Claude uses no external image model and no pre-rendered or traced reference images. Each piece is a Python program, somewhere between 1,000 and 2,000 lines, that drives a simulated paint engine. That makes this closer to agentic image editing than to generation in the usual sense. A language model selects tools, issues commands, checks the result and adjusts. The difference is that here the model is also the one holding the brush.
For practitioners, the interesting property is that the artifact is code. You can read the stroke list, see where a given mark came from, and change one region without re-running the whole image. Diffusion models offer nothing comparable; their intermediate states are not a plan you can audit. Whether this scales to everyday image work is a separate question, since a 700,000-stroke scene implies a lot of compute and a lot of tokens for a single output.

Earlier attempts with the sibling model Opus 5.5 drew criticism for simply imitating existing artists. Eaton's response was to have Fable 5.2 invent its own artist personas, each with a fictional backstory and a consistent style. Even so, the model needs several thousand brushstrokes per painting, and Eaton steers it with comments between passes.
No undo means every stroke is a commitment
The most revealing experiment came from Anthropic engineer Michael Graczyk, who shared a chat log and video of Fable 5.2 painting a bird at sunrise. The model could only simulate the physics of bristles, wet paint and canvas texture through code. It had to write every stroke as its own coordinate line, and it couldn't erase anything once placed.
That constraint is what separates the method from AI video. Video models like Flux 3 produce frame sequences and maintain temporal consistency directly. Here, the model has to plan forward and live with what it has already done. Graczyk's 21-second video tracks the painting through exactly 111 strokes on a blank canvas. The first stroke was specified with the color code #30346a, a width of 90 pixels and five slightly wobbling waypoints. The model said it added the roughly seven-pixel wobble on purpose, because a human arm doesn't draw a perfectly straight line either.
The self-correction is the part I find most interesting. Between passes, the model looked at the canvas and responded to its own errors. When the bird's back came out too thin and scraggly, it laid a bolder stroke over the top. The stray bristle marks along the edges now read as ruffled feathers. That's a repair decision made on visual feedback, not a rerun from scratch.
A second piece, a 280-stroke scene of two people painting at dusk, shows the same behavior under harder conditions. A late lighting effect accidentally smeared paint tubes and a cup on the table. Fable 5.2 repainted those objects after the fact. It also had both figures paint with their outer hands so their inner shoulders could touch, as the prompt specified.
Does the spatial reasoning carry over to robots?
Anthropic positions Fable 5.2 as a model built for long-horizon technical work, the kind that requires planning step by step and correcting course under physical constraints. The company says its sibling Mythos 5.2 targets vetted researchers in cybersecurity and biology. In internal tests, Fable 5.2 solved two open problems in black hole physics, designed three working electronic devices with circuit board manufacturer Diode, and used more than 1,000 sub-agents to program its own laptop operating system over eight days. Those are company-reported results, and they're hard to evaluate without the underlying details.
The more testable claim involves physical robots. AI researcher Aris Zhu set Fable 5.2 against OpenAI's GPT-6 Astra, with each model driving a robot arm to paint Van Gogh's "The Starry Night." Anthropic reports 64.9 percent for Fable 5.2 on its internal RoboDojo Sim benchmark, against 29.8 percent for GPT-6 Astra. That's a wide gap, but it comes from a benchmark Anthropic built and runs, so it tells you more about the vendor's evaluation setup than about a settled ranking.
Zhu's hands-on comparison is more sobering. Astra painted noticeably faster, and so far only OpenAI's model has managed to stand a domino on end. It did that by slowly loosening its gripper and using gravity as a pivot. That's a fine motor skill that Fable 5.2 hasn't shown in this test, and it suggests that simulated planning and physical dexterity are separate problems.
Here's my read: the painting work is less about art than about whether a language model can hold a plan, act irreversibly and repair its own errors. Those are the properties that matter for robotics, for long coding tasks and for any agent working in a space where undo isn't free. What to watch next is whether the stroke-by-stroke method holds up across more prompts and whether the robot results survive comparison outside one vendor's benchmark.