GPT-6.2 Dual-Model Hands-On: How Big Is the Gap Between Astra and Sol in Clock-Making and Game-Building?

GPT-6.2 Astra and Sol tested on three tasks: strong execution, but aesthetics and mechanical depth still trail Anthropic models.
The article compares GPT-6.2 Astra, GPT-6.2 Sol, CloudFable 5.2, and Opus 5.5 across three same-brief tests: Blender clock-making, neon cube shooter, and Formula racing. Astra executes strongly, responds to revision feedback, and spends budget extremely fast—both games hit the $200 cap in about 5 hours; Sol is extremely cheap, completing the clock workshop for under $5 and all three tests for $197, but has enemy-trigger defects and a racing performance problem that drops to 2 FPS. In the clock challenge, both models mesh gears correctly but lack an escapement, so the clock does not run, while Fable and Opus produced clocks that actually work. Anthropic models still lead in games and aesthetics. The conclusion is that model competition is shifting from "can it complete the task" to engineering dimensions such as budget efficiency, agent scheduling, and aesthetic detail.
OpenAI released GPT-6.2 Astra and GPT-6.2 Sol at the same time, with a clear official positioning: Astra tackles the hardest professional work, while Sol takes the everyday route at only a quarter of the price. A Bilibili creator put both models through the same three-task suite—Blender clock-making, neon cube shooter, and Formula racing—and also brought in CloudFable 5.2 and Opus 5.5 for a side-by-side comparison. The conclusions are far more complex than a benchmark table: Astra really can do the work, but gaps in gaming and aesthetics remain; Sol is absurdly cheap, yet it also reveals compromises at key points.
Test Rules: Same Three Challenges, Capped Budget
The three tests use the same brief and the same rule set as last week's CloudFable 5.2 run. The first challenge, Clockwork, involves building a clockmaker's workshop in an old clock tower in Blender, with only a prompt and no reference images; the second, Neon Cube, is a shooter set in neon streets inside a giant cube; the third, Formula, is a racing game where you compete against AI drivers. The latter two games are both built in the Godot engine, all runs use ultra-high effort, a maximum of 3 auxiliary agents, image generation is disabled throughout, and costs are calculated based on API estimates in each model's own logs. The game tests have a $200 hard cap, with a check at $100 that provides revision feedback.

What makes the first challenge special is this: there is no Blender interface and no MCP, so the model must write its own Python script and drive Blender headlessly from the command line. This effectively puts "can it use tools" directly on the table.
The difference between headless mode and what MCP does
Blender's headless mode means not launching a graphical user interface and instead executing Python scripts directly from the command line, with the bpy module controlling scenes, objects, materials, and rendering. In this mode the model cannot "see" the interface or click with a mouse; every operation must be translated into precise API calls, so it directly tests how deeply the model understands the software's object model. MCP (Model Context Protocol) is a standard protocol that lets models call external tool servers. If Blender provided an MCP interface, the model could complete operations through structured tool descriptions with a higher tolerance for error. The test deliberately disables MCP, stripping away that "handrail" and requiring the model to write and debug scripts itself, thereby exposing its planning and error-correction ability when there are no tool hints.
Clock-Making Test: The Gears Are Right, but the Clock Doesn't Run
The workshop Astra built has plenty of detail—a large background window and scattered objects on the desk are all richly rendered—but the large clock looks rather heavy. Sol's clock is even heavier, yet placed side by side, the layouts are almost identical: a large dial in the back, a disassembled clock in the middle, gears beside it, and glass on the left. The brief only required these elements to exist, with the model deciding their positions, and the two models independently chose the same arrangement. The creator checked the file locks: neither had ever opened the other's folder, so there was no peeking. The earlier GPT-6 Astra had a different layout but a highly similar color scheme—the same green-and-gold pairing, the same star chart on the dial—and both new models even used the number "7."
The truly critical question is: does the clock run? After round-by-round measurement, the three gears mesh correctly, rotate in opposite directions, and their speeds strictly correspond to their tooth counts—the mechanical structure is sound. But the pendulum just swings on its own and drives nothing; there is no escapement. Both models delivered a gearbox with a pendulum, not a clock that actually ticks. CloudFable and Opus both produced real escapements in this challenge.

In terms of price, Astra cost $18 and Sol under $5. Looking across all historical results: Fable 5.2 was $36, Opus 5.5 was $42, GPT-6 Astra was $30, Kimi was $16, and the old Fable 5.1 was as high as $125. Sol is the cheapest model ever in this test, and the creator also said plainly that it was the worst performer.
Why the escapement is the core of a mechanical clock
The escapement is the device in a mechanical clock that converts continuous power into regular ticks; a typical structure consists of an escape wheel and a pallet fork: each swing of the pendulum or balance wheel releases one tooth, while also replenishing energy to maintain oscillation. Without an escapement, the gear train can only spin freely or be driven arbitrarily by the pendulum, with no controlled speed, and thus cannot keep time. For a model, this requires understanding the physical constraint that "the energy-transfer chain must be closed," not merely making parts visually mesh. Correct gear meshing proves only geometric relationships; a missing escapement shows that the model did not build a functional model of "a clock as a controlled oscillating system"—which is exactly the key point that distinguishes model depth in this round of testing.
Neon Cube: Astra Burns Through the Budget, Sol Spends Only Half
The shooter challenge starts with Astra. Early versions could already walk and fight normally on the walls, the shooting feel was good, and the gun was held in the right position, but there were too few enemies, right-click aiming was missing, and the night was too bright. Sol was astonishingly slow, taking 9 hours to spend the first $100, and the creator had to urge it to use more agents and spend the budget. When actually played, there was not a single enemy on the street—enemies only appear after you turn on a certain relay.
In terms of color scheme, the GPT series has its own style: Sol 6.1, Sol 6.2, and Astra 6.2 look similar, overall brighter with paler orange, and Astra 6.2 is the best among them. But the creator prefers the style of Anthropic models, believing that although Opus and Fable each have shortcomings, their aesthetics are more distinctive.

After submitting one round of feedback and continuing to iterate: Astra's right-click aiming worked, the night became darker, and the $200 budget was spent down to the last cent; Sol put enemies directly on the street and ultimately spent only $145. One detail in Astra's version was impressive—puddles on the ground realistically reflected the signs and buildings above, and the model wrote a dedicated shader for this. Sol's street had only the faint reflections of streetlights. Even so, the creator still awarded this challenge to Fable and Opus, on the grounds that their style and aesthetics were more appealing.
Ground puddle reflections and custom shaders
Puddles reflecting signs and buildings usually require screen-space reflections (SSR) or planar reflections: the former reuses the depth and color buffers of the already rendered frame for ray marching, while the latter renders the scene again with a mirrored camera. Astra writing a dedicated shader means it handled the reflection matrix, normal perturbation, and Fresnel attenuation itself in Godot, rather than simply applying an environment map. This kind of effect is a "look amplifier" in games, but it is sensitive to both performance and correctness. The fact that it actively implemented this detail shows that the model has some graphics knowledge and the ability to search engine APIs; whereas Sol produced only faint streetlight reflections, reflecting noticeably conservative investment in visual richness.
Formula Racing: Astra Fixes the Handling, Sol Drops to 2 FPS
The racing challenge also has a $200 cap with a check at $100. Astra's early visuals were good, but it was simply undrivable—every corner threw the player into a spin, the background was weak, and the finger shapes in the cockpit were clearly wrong. On Sol's side, the creator made a mistake: because the budget was being consumed so slowly, he allowed Sol to submit early, and as a result it submitted after 27 minutes having spent only $28. For that price it wasn't bad, far better than the previous Sol 6.1—there were hills, low-poly trees, and a rather beautiful sky, and the steering was even easier to drive than Astra's, but overall it felt like a toy, lacked a sense of speed, had thin engine sounds, and the hand modeling on the steering wheel was terrible.

After one round of fixes, Astra's driving problems were solved—it no longer spun at every corner—and it added excellent-looking mountains, four types of trees, and a village with a clock tower, once again spending the entire budget. Sol's car became heavier, the camera reacted to speed, the engine sound grew louder, and the lighting effects were new, but there was an unavoidable problem: at a fixed moment in the game, every attempt dropped to about 2 FPS. The creator said he would not continue fixing it. The winner of this challenge was still Fable and Opus, with obvious differences in detail, such as hand modeling, and better handling feel; although Anthropic models are slower, they understand games better.
Common causes of frame drops at a fixed moment
A racing scene suddenly dropping to about 2 FPS at a fixed moment is usually not random fluctuation, but the triggering of some expensive event: for example, loading distant chunks for the first time, spawning large numbers of particles or shadows, compiling shaders, or some script concentrating physics queries at a specific track position. The fact that the frame rate reproduces at a "fixed moment" indicates it is strongly correlated with in-game time or position, rather than hardware thermal throttling. For a model, locating this kind of problem requires reading performance profiling data, inspecting dynamically instantiated nodes in the scene tree, and determining whether it is a rendering bottleneck or a script blockage. Sol failed to fix it, exposing an incomplete debugging chain—it can write a runnable prototype, but lacks systematic performance attribution ability.
The Bill and the Conclusion: Fast-Gun Astra, Cheap-Worker Sol
Total cost across the three tests: Astra $419, Sol $197, and last week's Fable 5.2 $357. The most obvious pattern is that Astra spends extremely quickly—both games hit the $200 cap in about 5 hours.
Overall, GPT-6.2 Astra is a model with strong execution ability: it can finish the work, listens to revision feedback, and spends exactly as much budget as it is given. Sol is cheap and slightly lazy, but building a clockmaker's workshop for $5 is itself astonishing enough. In the game category, Fable and Opus still lead, though Astra is already very close.
For real users, the signal from this set of tests is that the gap between models is shifting from "can it complete the task" to "is it good to use after completion." Budget consumption speed, agent scheduling strategy, and the quality of responses to revision feedback—these engineering-level behaviors often determine the actual cost of a task more than a benchmark table. Astra is suitable for hard tasks that need to be done right the first time, while Sol is suitable for cost-sensitive scenarios where rough results are acceptable; and if the goal is games or visual aesthetics, Anthropic models are still the safer choice for now.
Related articles

GPT-6.2 and Astra Launch Together: OpenAI Has Finally Figured Out Its Release Cadence
OpenAI releases GPT-6.2 Sol and Astra together, with Plus users able to try them in ChatGPT Work and Codex. This article breaks down the positioning differences between the two models, Astra's practical use in long-document retrieval and rewriting, and how the simultaneous dual-model launch affects user workflows.

GPT-6.2 Astra and Sol Released: A Big Cost Drop, and How to Choose Between the Two Models
OpenAI releases GPT-6.2 Astra and GPT-6.2 Sol: Astra tackles professional tasks, Sol targets low-cost everyday use, with cost per task cut to under a third.

The Father of Vibe Coding's Multi-Model Strategy: Replicate His AI Coding Setup for Free
The creator of Vibe Coding never trusts a single AI model—he uses multi-model division of labor, with one writing code and one reviewing. This article analyzes his free, replicable multi-model setup and the risks of single-model tools removing models.