How to compare AI models when creating interactive 3D scenes

Comparing AI models for creating interactive 3D scenes shows how different systems perform the same engineering task: assembling a scene, writing interaction logic, and refining the prototype until it is suitable for demonstration.

Generation speed alone does not indicate the quality of the result.

In the experiment described, GPT-6 Astra and Claude Opus 5.5 were compared not using advertising benchmarks, but through two applied scenarios: an interactive Japanese vending machine and an insectarium with complex insect behavior. The observations belong to the experiment's author and characterize a specific run rather than all possible operating modes of the models.

How to formulate the same task for two AI models

The same prompt should describe the object, required elements, interactive actions, and readiness criteria. If one model is allowed to improvise an entire website while the other is assigned only the scene, the final comparison will mix generation quality with the amount of work added independently.

For an 3D prototype, it is convenient to divide the requirements into four levels:

• Geometry. The model must reproduce the machine's shape, housing, screen, buttons, cans, wires, and surroundings.
• Visual elements. Materials, textures, lighting, labels, shadows, and correspondence with the source image are checked.
• Interactivity. The button must respond when pressed, display the selected product, and launch the required animation.
• Constraints. The task specifies exactly what must be created, while extra pages, menus, or additional modes do not count as an advantage.

This format turns an impression of the demonstration into a verifiable checklist. It also helps distinguish an attractive image from a working prototype in which the user can actually perform the intended action.

Which parameters to record before starting

Before testing begins, record the model, reasoning mode, shell, source materials, limits, start time, and completion time. In the experiment, both models were run in High mode without overthinking through the CodeX CLI and Claude Code shells. Original subscriptions costing 20 dollars each were used for both services, but this was a condition of the specific experiment, not a universal current price.

The cost of using the model should be recorded separately. The experiment's author assessed GPT-6 Astra as a model that cost approximately twice as much as Claude Opus 5.5, with the difference, in the author's estimate, slightly exceeding twofold. This information cannot be applied to APIs or other pricing plans without separate verification: subscriptions, CLI limits, and token-based billing measure different things.

The run log should store not only the final time, but also the number of corrections, the amount of the limit used, build errors, the number of manual edits, and the list of unmet requirements. If a model creates a scene quickly but leaves buttons inaccessible, that does not constitute complete success.

Test 1: interactive Japanese vending machine

The first task required reproducing a Japanese vending machine from an image as an 3D model. GPT-6 Astra completed the project in 12 minutes 18 seconds, whereas Claude Opus 5.5 took about 35 minutes. The GPT-6 Astra version also included a website, even though the task author requested only an 3D model and considered this result unnecessary.

In the GPT-6 Astra scene, clickable buttons selected drinks, the machine displayed names and prices, including 150 and 160 yen, and then dispensed the corresponding cans. The visual elements included labels, switches, power toggles, and designed packaging. The author assessed the result as well made, but noted that some of the lower buttons remained inaccessible.

Claude Opus 5.5 created a separate interactive scene without an additional website. In the author's assessment, it looked more complete and detailed: the machine had a connected wire, an animation for dispensing products, prices, instructions, and coin visualization. Some elements could not be clicked, so the visual development did not mean full functional readiness.

How to test scene functionality

Testing should follow the same user path. First, press every button, then compare the name and price of the selected product with the displayed data, and finally check that the can is dispensed, that pressing again works, and that the scene returns to its initial state.

What should you do if an element looks like a button but does not respond? Record it as an interactivity defect, even when the rest of the scene works. Otherwise, the evaluation will be inflated by decorative details.

1. Check that all visible buttons are accessible.
2. Match the button's action to the selected product.
3. Check that names and prices are correct.
4. Launch the dispensing animation and make sure the object appears in the right place.
5. Repeat the scenario after reloading or resetting the scene.

Test 2: 3D insectarium with insect behavior

The second task tested not only appearance, but also movement logic. The models were asked to create an 3D insectarium with butterflies, stick insects, a praying mantis, vegetation, stones, glass, shadows, and a grid, as well as configure complex object behavior.

GPT-6 Astra completed the scene in 15 minutes. In its version, butterflies flew and landed on branches, while the other insects moved through looped animations. The scene contained vegetation, stones, shadows, and a grid. The author also noted that switching to nighttime did not change the animations, so the lighting change did not appear to be a complete change in the environment's state.

Claude Opus 5.5 took 41 minute. In its version, the stick insects moved their legs, crawled along branches and glass, moved between objects, and bent their bodies while moving. The author specifically noted that the butterflies landed in different places and that a stick insect moved across the glass. In the author's assessment, Claude's behavior logic was noticeably deeper, although the difference in overall quality seemed small at first glance.

This test demonstrates the difference between a looped animation and environment-dependent behavior. The former imitates movement by repeating a short clip, while the latter links an object to surfaces, paths, destinations, and changes in the positions of body parts. The second option is more valuable for an interactive scene when the task requires observable simulation rather than merely decorative motion.

How to evaluate visual quality and logic separately

It is better to base the final evaluation on several independent criteria. A score for appearance should not compensate for broken actions, and high speed should not conceal an unmet requirement.

The experiment author's assessment was as follows: GPT-6 Astra more often completed tasks faster and was well suited to rapid visual prototyping, whereas Claude Opus 5.5 took more time and developed the behavior and structure of the scene in greater depth. This observation does not negate GPT-6 Astra's strengths: when transferring an image into 3D, the author rated its result as very similar to and well developed compared with the source, while Claude seemed less successful and added unnecessary visual clutter.

Why faster generation does not always mean a better result

A fast response is useful when the main goal is testing an idea, preparing a demo, or obtaining a foundation for manual refinement. It becomes a disadvantage if the model reduces the number of states, repeats a simple animation, ignores some buttons, or adds inconsistent elements to make the scene appear visually complete.

Slow work also does not guarantee superiority. Claude Opus 5.5 created more advanced insect behavior, but some elements in the vending machine scene could not be clicked. GPT-6 Astra added a website beyond the task, which increased the scope of the result but did not improve its compliance with the original request. The winner should be chosen according to the project's priorities, not by a single impressive frame.

For a repeatable comparison, it is useful to run each model on several tasks: image transfer, a scene with an interface, object simulation, and a short game. After each run, save the original prompt, time, project version, defect list, and a snapshot of the limits. Only a series of consistently documented tests can show where a model is genuinely stronger and where the result was shaped by the specifics of a single task.

Final report template

• Task: brief description of the scene and required functions.
• Conditions: models, modes, CLI shells, subscriptions, and limits.
• Time: duration until the first working version and until the final run.
• Result: geometry, materials, interface, animations, and object behavior.
• Defects: inaccessible elements, logic errors, extra components, and problems after reloading.
• Conclusion: which model is better suited to speed, visual similarity, interactivity, or deep logic.

This report maintains the distinction between fact and assessment: the time and identified defects relate to a specific run, while conclusions about the model's strengths remain the experiment author's interpretation. For a developer, designer, or SEO specialist, this is more reliable than choosing an AI based on the model name, a public benchmark, or a single impressive demo.