The industry is currently obsessed with the transition from chatbots to agents. The promise is simple: an AI that does not just tell you how to solve a problem but actually executes the solution using a suite of tools. However, the gap between a model that can call a function and a model that can iteratively refine a complex task remains vast. This week, a rigorous stress test known as the drawing arena revealed a startling reality about how the leading vision models handle spatial reasoning and self-correction, proving that more iterations do not always lead to better art.

The Mechanics of the Drawing Arena

The experiment pitted four heavyweight vision models against one another: GPT-5.6 Sol, Claude Fable 5, Grok 4.5, and Gemini 3.6 Flash. The objective was not to generate a pixel-perfect image via diffusion, but to use a set of discrete colored pencil tools to draw. The models had access to `set_color`, `set_brush`, and `set_pressure` to define their strokes, and a `draw` command to execute them. To refine their work, they utilized `view_canvas`, allowing the model to see its current progress and decide on the next move. The test consisted of 28 total drawings, derived from a combination of two target images and five text prompts.

One of the most concerning findings was the phenomenon of performance decay. In every single target execution, the final quality of the drawing was lower than the peak quality achieved during the process. For instance, Gemini 3.6 Flash reached a peak Structural Similarity Index Measure (SSIM) of 0.449 while working on the Mona Lisa, only to see that score plummet to 0.337 by the time it finished. GPT-5.6 Sol followed a similar trajectory on the same task, hitting a peak of 0.352 before settling at a final score of 0.325. This suggests that as models enter a loop of self-correction via `view_canvas`, they often over-correct or introduce new errors, leading to a regression in quality.

The Paradox of Metrics and the Cost of Quality

When analyzing the financial overhead of these agents, the disparity was staggering. To produce just seven drawings, Claude Fable 5 incurred an estimated cost of approximately $160. In stark contrast, GPT-5.6 Sol completed the same volume of work for $7.74. Other models fell in the middle, with Grok 4.5 costing $9.21 and Gemini 3.6 Flash costing $12.87. This means Claude Fable 5 was roughly 20 times more expensive than GPT-5.6 Sol to achieve a similar output, creating a massive barrier for any practical enterprise deployment.

Furthermore, the data revealed a significant disconnect between quantitative metrics and human perception. On paper, Gemini 3.6 Flash was the winner, recording the highest raw SSIM scores for both peak and final results. SSIM is designed to measure the structural similarity between two images, but it often fails to capture artistic nuance. In actual visual assessments, GPT-5.6 Sol was the clear victor. Its renderings of the Starry Night and a rose were the most preferred across the entire batch, consistently outperforming the other models in detail and composition. The lesson is clear: a higher similarity score does not necessarily equate to a better visual experience for the user.

This divergence extends to how the models actually use their tools. Out of 1,349 total tool calls, Grok 4.5 spent 65% of its effort on configuration tools like `set_color`, `set_brush`, and `set_pressure`. It treated every setting as a separate step, leading to an inefficient, bloated process that ultimately failed to produce usable results. GPT-5.6 Sol took the opposite approach. It never called the configuration tools as standalone commands, instead processing settings inline during the `draw` command. This streamlined execution minimized the number of calls and maximized efficiency. Meanwhile, Gemini 3.6 Flash exhibited an obsessive review strategy, spending about one-third of its total calls on `view_canvas` to scrutinize its work, yet this diligence did not prevent the eventual drop in quality.

While Claude Fable 5 managed to secure second place in terms of overall quality, its extreme latency and 20x cost multiplier make it an inefficient choice for real-world applications. The trade-off between a marginal increase in quality and a vertical spike in cost is simply not sustainable for most developers.

For those building LLM-based agents, these results highlight a critical architectural need. To prevent agents from falling into infinite review loops that degrade the final output, developers must implement early stopping criteria that can detect when a model has hit its performance peak and terminate the process before the quality begins to slide.