How to Make GPT-5.6, Claude, Gemini & Grok Draw the Mona Lisa

The #1 mistake people are making with the viral TryAI drawing arena? They watch the clips, see GPT-5.6 Sol beat Claude Fable 5, and conclude Claude is bad at drawing. That’s the wrong takeaway. The real lesson – and the one nobody’s turning into a tutorial – is that your loop design decides who wins, not the model. Set it up naively and Claude will happily burn $160 of your API credits on seven pictures (as of late July 2026 pricing – check current rates before you run this).

What follows is a hands-on walkthrough for building your own drawing arena with GPT-5.6, Claude, Gemini, and Grok. We’ll reverse-engineer what TryAI did, fix the setup traps that made results look weirder than they should have been, and give you three lighter alternatives if you just want a quick comparison. If you’ve ever wanted to see a frontier LLM actually use tools instead of just talking about them, this is the most visual way to do it.

What the drawing arena actually is

The setup is simple on purpose. TryAI built a rig where the model sets a color, tip width, and pressure, lays down batches of strokes, smudges to blend, erases, and calls view_canvas to see its own work and decide what to fix. That’s it. No image generation model in the middle. No diffusion. Just a vision-capable LLM driving a pencil.

They ran it on four models – GPT-5.6 Sol, Claude Fable 5, Grok 4.5, and Gemini 3.6 Flash – across two targets (Mona Lisa and Van Gogh’s Starry Night) and five open-ended prompts, for 28 drawings total. The Mona Lisa run is the one everyone’s sharing because you can score it objectively: how close does the canvas look to the real thing?

Here’s what the community actually noticed under the hood. Over on Hacker News, one commenter pointed out that the models draw concepts, not light. On the rose-in-vase prompt, some models just went “blue = glass, green = stem, red = rose” instead of understanding shading and refraction. That’s the interesting bit – a vision model can recognize a Mona Lisa in a photo but struggles to reproduce one stroke by stroke.

Step-by-step: run the arena yourself

You need three things: API keys, a canvas library (any 2D drawing lib works – SVG, PIL, HTML canvas), and a tool schema. Here’s the minimum toolset that matches TryAI’s setup:

tools = [
 {"name": "set_color", "params": {"hex": "string"}},
 {"name": "set_pressure", "params": {"value": "0.0-1.0"}},
 {"name": "set_tip", "params": {"px": "int 1-20"}},
 {"name": "stroke_batch", "params": {"points": [[x,y], ...]}},
 {"name": "smudge", "params": {"region": [x,y,w,h]}},
 {"name": "erase", "params": {"region": [x,y,w,h]}},
 {"name": "view_canvas", "params": {}} # returns PNG back to the model
]

The view_canvas tool is the whole point. Every time the model calls it, you send the current image back in the next turn’s context. That’s how self-critique happens – and it’s also where costs explode, because each review re-uploads the growing canvas as an image token payload.

Prompt template

1. System prompt: “You have a blank 512×512 canvas and colored pencils. Reproduce this target image. Call view_canvas whenever you want to see your progress. Stop when satisfied.”
2. User message: the target image (Mona Lisa JPEG).
3. Loop: execute each tool call, update the canvas server-side, feed results back.
4. Hard cap: stop at N iterations or $X spend (see next section for why).

The pitfalls that will wreck your run

Four traps. All of them either kill your budget or corrupt your results.

1. No iteration cap = the $160 mistake

As of late July 2026, Claude Fable 5 cost $160.58 across its seven drawings – roughly 20x GPT-5.6 Sol ($7.74), Grok 4.5 ($9.21), or Gemini 3.6 Flash ($12.87). Why? Claude reviewed its Mona Lisa 27 times, but similarity was essentially flat after about the fifth review. It just kept looking. Set a hard cap of 8-10 view_canvas calls per run. You lose nothing on output quality.

2. The over-revision collapse

This is the weird one. Gemini 3.6 Flash reviewed the most (about 23 times per drawing) and reached the highest peak of the whole batch – 0.449 similarity on the Mona Lisa – then slid all the way back to 0.337 by the end. It painted over its own best draft.

Fix: after every view_canvas, snapshot the canvas AND score it against the target (SSIM or CLIP similarity works). Return the highest-scoring snapshot at the end, not the last one.

3. Cache invalidation

Grok used by far the most tokens (34M) but stayed cheap because roughly 98% were cached reads at a fraction of the input rate. Gemini also leaned heavily on cached reads – even at 27.7M tokens it stayed modest. The catch: prompt caching only works when the prefix bytes are identical. Regenerate your system prompt with a timestamp or a random seed each turn, and you kill the cache. Grok’s bill quietly climbs.

4. Counting tool calls, not strokes

Grok 4.5 made 1,349 tool calls across its runs – 65% of them setup adjustments (set_color, set_pressure, set_tip). If you rate-limit by “total tool calls,” Grok looks like it’s working three times harder than it actually is. Rate-limit by stroke_batch calls only, or Grok will hit your ceiling before it draws a single face.

Pro tip: before you feed the model a Mona Lisa, feed it a red square. If it can’t call set_color("#FF0000") and stroke_batch to fill 50 pixels, your tool schema has a bug. Debug on trivial targets first – you’ll save hours (and dollars).

How the four models actually behaved

According to IBM Think’s write-up and TryAI’s own data (both published late July 2026):

Self-critique loops are a core feature of today’s AI agents – the theory being that stopping to check your work should improve the final result. After watching four frontier models repeatedly paint over their own best sketches, it’s worth asking: how often does the same thing happen on tasks where we can’t see every revision? Code reviews, long-form drafts, multi-step research? There’s no similarity score to catch the collapse there.

Alternatives if you don’t want to build the full arena

You can get 80% of the insight in 20% of the code:

• SVG-only mode: ask each model to output an SVG of the Mona Lisa in one shot. No tools, no loop. Cheap and quick, but you miss the self-critique behavior – which is the whole point.
• Turtle graphics: give the model a Python turtle environment and one function call per turn. Easier to instrument than a full canvas library. Terrible for shading, great for testing agent planning.
• ASCII art baseline: run the same prompt against all four models with “draw Mona Lisa in ASCII, 40 columns” – no tools required, and the differences in spatial reasoning show up instantly.

None of these will match the visual drama of the full arena. But if you’re just trying to see how different models plan multi-step visual tasks, the SVG version takes ten minutes.

FAQ

Do I need a vision-capable model, or will any LLM work?

Vision is required. The view_canvas tool sends an image back – a text-only model can’t interpret it and will keep drawing blind.

Why does Claude cost 20x more if its output is second-best?

Claude Fable 5 has higher per-token pricing than the other three – and it called view_canvas 27 times on the Mona Lisa alone. Each call re-sends the canvas as image tokens. Five reviews would have covered the same quality ground, based on TryAI’s similarity data showing the plateau hits early.

Can I reproduce this on a $20/month consumer plan?

No – this is API-only. Consumer chat interfaces don’t expose the tool-calling loop, and they don’t let you re-inject the canvas image as a tool result. You’ll need developer API access to each provider. A rough working estimate (not measured data): if you cap view_canvas to 6 calls per run and use the same system prompt verbatim each time (to keep caching intact), you’ll likely stay under $50 total for a four-model Mona Lisa + one open prompt run. But API prices change, and the exact figure depends on which model you use most – check your provider’s current pricing page before committing.

Your next step

Pick one model – GPT-5.6 Sol is the cheapest starting point – and build the four-tool version (set_color, stroke_batch, view_canvas, stop). Skip smudge and erase for v1. Feed it a red circle as the target. Once it can reproduce a circle in under 10 iterations, you’re ready to hand it the Mona Lisa.