GPT-6.1 Terra vs Sol vs 6 Astra: Hands-On Comparison of Three Models and How to Choose

Three Models Head-to-Head: A Hands-On Test of "Getting Work Done Efficiently"

In his Day 7 test, Bilibili creator "He Ji" put GPT-6.1 Terra, GPT-6.1 Sol, and GPT-6 Astra through the same task suite for a side-by-side comparison. The core question was straightforward: of the three AIs, which one gets the job done faster and better?

This isn't a benchmark-style parameter shootout but a hands-on capability test built around three specific challenges—animation generation, image understanding and regeneration, and web development. Each challenge has clearly defined observation points, and viewers ultimately pick A, B, or C.

According to the creator's test design, the three challenges correspond to three typical scenarios: multimodal generation, cross-modal understanding, and code implementation. This task mix is closer to real-world use than a single benchmark: users often need a model to deliver stable output across a continuous series of different task types.

Challenge 1: Riding a Bike While Carrying a Kettle—Whose Motion Makes More Sense?

The first challenge asks the models to generate an animation of "riding a bicycle while carrying a kettle," with the observation points being whether the wheels, pedals, and legs all move. This tests the model's understanding of physical action chains—cycling is a dynamic process involving multiple coordinated parts, and the wheel rotation, pedal cycle, and leg pedaling must all be logically consistent.

The three models' outputs diverged noticeably. A's leg lines overlap, indicating structural conflicts in the limbs during motion; B's pedals and legs shift together, showing a relatively complete motion linkage; C maintains clean lines, but whether that simplicity means simplified motion detail needs to be judged against the full animation.

The key trade-off in this challenge is between motion completeness and visual simplicity. Overlapping leg lines are a typical generation artifact, while pedals and legs shifting in sync is closer to real cycling motion. The creator doesn't give a direct answer but leaves the judgment to viewers—which itself suggests the gap between the three models isn't overwhelming and that each performs differently depending on task type.

Action chain understanding is a key capability for video generation models: the model must not only generate a plausible frame-by-frame sequence but also maintain physical causality across frames. In cycling, for example, the legs pedaling drive the pedals to rotate, which in turn drive the wheels—the three form a causal chain. A common failure mode in generative models is "locally plausible, globally broken"—a single frame looks anatomically complete, but across consecutive frames limbs intersect and parts fall out of alignment. When evaluating such animations, you typically need to check both structural stability (whether limbs overlap or clip through) and motion consistency (whether the linkage between parts follows physical logic); missing either makes the animation unusable.

Challenge 2: Describe First, Then Generate—Cross-Modal Consistency Becomes Key

The second challenge is "describe the original image": first have the model describe an image, then regenerate an image based on that description. This is effectively a closed-loop test of image understanding → text expression → image reconstruction, examining whether the model can preserve key information across modal transitions.

This type of task is very common in real workflows—for example, turning a design mockup into a description, turning a description into accompanying visuals, or having content creators reproduce a reference image from text. The difficulty isn't single-pass generation quality but whether the description captures the core elements of the original image and whether the generation faithfully reproduces those elements.

The source material doesn't disclose the specific description text and generated results for the three models in this challenge, so it's impossible to say which one is better at cross-modal consistency. But based on the test design, this challenge is more likely to widen the gap between models: description accuracy and generation fidelity are two independent capabilities, and a failure in either will cause the final result to drift from the original.

Cross-modal consistency measures a model's ability to preserve semantics when transferring information between modalities. In the "image → text → image" loop, it involves at least two stages: first, whether the image description covers the key elements of the original (subject, composition, style, color relationships, etc.); second, whether the text-to-image generation faithfully reproduces those elements. This metric differs from raw image generation quality—a visually appealing generated image may deviate significantly from the original. The industry commonly uses metrics like CLIP Score for quantitative evaluation, computing the similarity between the generated and original images in embedding space, but human judgment remains irreplaceable for composition and detail fidelity.

Challenge 3: A Forest Cottage Webpage—Code Implementation Shows Its True Colors

The third challenge asks for "a webpage of a rural cottage in the forest," with an added requirement: add movement controls. This challenge shifts from visual generation to front-end development, testing whether the model can turn natural language requirements into runnable webpage code and maintain context coherence when additional requirements are added.

The "added requirement" is the highlight of this challenge. In real development, requirements are rarely fully specified upfront; models need to make incremental modifications on top of existing code rather than starting from scratch. Adding movement controls means the model must understand interaction logic, not just static page layout.

For content creators and small projects, this capability directly determines whether the model can serve as a "one-sentence-to-prototype" tool. The source material again doesn't provide a final code quality comparison of the three models, but the creator placing this challenge last suggests code generation is a highly discriminating dimension.

Incremental code editing is a core scenario in multi-turn conversational programming. The model needs to locate modification points within the existing code context, leave untouched parts unchanged, and make new functionality compatible with the existing structure. This differs in difficulty from generating a full page from scratch: the longer the context, the more likely the model is to "forget" established conventions or make destructive changes. When evaluating this capability, common observation points include: whether only necessary parts are modified, whether new interaction logic (such as movement controls) conflicts with the existing layout, and whether the code runs directly in the browser. For "one-sentence-to-prototype" tools, the reliability of incremental editing often determines practical usability more than first-pass generation quality.

How to Choose Among the Three Models: Match by Task Type

Combining the three challenges, the positioning differences among the three models can be broken down by task dimension:

• Animation and multimodal generation: Focus on motion logic completeness and visual structural stability. In Challenge 1, B's motion linkage was relatively complete, A showed structural issues with overlapping leg lines, and C presented clean lines but with detail level to be determined.
• Image understanding and regeneration: Suitable for scenarios requiring "look, describe, then draw," such as design assistance and content reproduction. Cross-modal consistency is the core metric.
• Web and code generation: Suitable for rapid prototyping, especially when requirements will be iteratively added. The added-requirement test in Challenge 3 simulates exactly this kind of real workflow.

According to the creator's setup in the video, the answer is in the comments section and points to "He Ji's" work. This interactive ending suggests the test results aren't a single-dimension win-or-lose but depend on which type of task the user values more.

Selection advice can be summarized as follows: if you mainly do visual content generation, prioritize animation structural soundness and visual stability; if your workflow involves image-to-description or description-to-image, focus on testing cross-modal consistency; if you use it for front-end prototypes or small tool development, code implementation and incremental editing capabilities are more critical. There is no absolute best among the three models—task fit is the basis for selection.

One-line Summary

Bilibili creator puts three GPT models through three challenges to test animation, cross-modal, and coding capabilities.

Paragraph Summary

Bilibili creator "He Ji" compares GPT-6.1 Terra, GPT-6.1 Sol, and GPT-6 Astra side by side under the same task suite, examining "who gets the job done faster and better" across three challenges: animation generation, image understanding and regeneration, and web development. In Challenge 1, generating a "riding a bike while carrying a kettle" animation, A showed structural issues with overlapping leg lines, B had relatively complete pedal-leg linkage, and C kept clean lines with detail to be determined; Challenge 2 used a "describe the original then regenerate" closed-loop test, making cross-modal consistency a key dimension; Challenge 3 required building a forest cottage webpage with an added movement-control requirement, simulating incremental editing in real development. The article concludes that there is no absolute best among the three models—selection should match the task type: visual generation calls for motion logic, cross-modal tasks call for consistency, and development calls for code implementation capability.