GPT-6 Astra vs Claude Fable 5.1 Tested: Same 3D Game Task, Different Results

In SandBase’s September 7 test, GPT-6 Astra and Claude Fable 5.1 received the same 3D game task. For developers comparing their generated code, the question was concrete: would the first returned file start, obey the puzzle rules, and let a player finish without a repair?

I gave both models the same test task: generate a 3D puzzle game that runs in a browser. Beyond looking at the graphics, I would check whether the character could move, the mechanisms could be activated, and the game could be completed.

Astra performed better in this test: all three generated games completed the task, responses arrived sooner, and request charges were lower. The clearest code failure appeared in Fable’s first attempt, where a mistake creating a light stopped initialization.

Key takeaway

• All three Astra games passed 15 functional checks, keyboard traversal, and reset.
• Fable’s initial three requests produced one pass, one initialization failure, and one missing code response. A separate supplemental request passed.
• Complete code responses took approximately 151–195 seconds for Astra and 253–294 seconds for Fable.
• SandBase API charges averaged approximately $0.42 for Astra and $1.21 for Fable across three captured code responses each. These are not the providers’ direct API prices.

The task: three rooms, two doors

The task was Aster Vault: three connected rooms and two doors. Restore the Relay, activate the Orbital apparatus, then collect the Aster Core. Move with WASD and mouse look, interact with E, and restart with R.

That is a short sequence, but its dependencies matter. The second mechanism must not work before power is restored. The core must not trigger victory before that mechanism is complete. A closed door must physically block movement; changing its color is not enough. Reset must restore the player, doors, and objectives, rather than merely remove the victory message.

Both models received the same requirements and had to return one HTML file using Three.js, a JavaScript library for rendering 3D scenes in the browser. The comparison stopped at first-pass code: no additional debugging rounds and no manually repaired version counted as a success.

Astra passed all three attempts

All three Astra games started and completed the sequence: power, first door, second mechanism, core, and reset. In the first version, restoring power opened the first door and updated the on-screen objective to the second room.

Door 1 is open; the objective has advanced to the Orbital apparatus.

Those are modest interactions, but they establish something a screenshot alone cannot. At this point, the displayed objective and the underlying game state agree. The interface does not announce an open door while an invisible collision barrier remains in place. The other two Astra versions completed the same checks.

Completing the sequence across three independent generations was Astra’s clearest advantage on this task. Submitting the same requirements repeatedly produced three usable files without source changes.

Fable’s first-run error

Fable’s first version failed at something more basic than puzzle design. While creating a point light, it tried to replace a read-only position property. The browser reported:

Cannot assign to read only property 'position' of object '#<PointLight>'

The code used Object.assign to assign a new position to the light. Here, it should have changed the coordinates of the existing position vector instead of replacing the property. Initialization stopped before the gameplay could run.

That error determined the first attempt’s outcome. Initialization stopped, so the rooms, objectives, and victory condition could not undergo further testing. Starting successfully was the first requirement, and this version failed it.

Fable’s third version had a different outcome. A warm-lit power chamber opens toward a blue second room. Activating the Relay updates its indicator, changes the objective, and opens the first door. Neither this version nor the successful supplemental version required source edits.

The Relay indicator is green, while Orbital and Core remain incomplete.

Fable’s initial batch recorded one pass, one initialization failure, and one request without captured code. The supplemental attempt is recorded separately as a pass.

Objectives, collision, and reset

Entering a scene is only the beginning. Each of the five working games passed 15 functional checks and a separate keyboard traversal: approach the mechanism, press E, walk through the doors, collect the core, and press R to reset.

The results break into three parts. Objective order: power must precede the second mechanism, which must precede core collection. Collision: both closed doors block movement and allow passage once open. Reset: pressing R after victory restores the player and objective state. All five games that started passed these checks.

The supplemental Fable artifact reaches its victory screen without a source edit.

Across the complete task, Astra passed with all three captured files. Fable passed with two of three captured files, including the supplement; one failed at startup. The measured difference was first-pass completion. The functional checks did not identify an additional gameplay gap among the versions that ran.

Response times and API costs

Among requests that returned complete code, Astra took approximately 151–195 seconds and Fable 253–294 seconds. These are observed API response times, including service-side handling and transmission, not isolated measurements of model reasoning speed.

The SandBase API bill showed an average of about $0.42 per captured Astra response and $1.21 per captured Fable response—approximately 2.91 times as much. Each average covers three complete code responses, including Fable’s version that failed to start.

The more expensive, slower requests did not produce better first-pass results here. Astra led on all three observations: three completed attempts, shorter response times, and lower average request charges.

Astra wins this test

Astra won this 3D game task: three original files passed, responses took roughly two and a half to just over three minutes, and SandBase API charges averaged about $0.42.

Fable’s initialization failure exposed a specific weakness: one incorrect library call made an entire generated file unusable. Its complete code responses also took longer and averaged about $1.21. In this first-pass comparison, Astra produced more successful attempts with less waiting and lower request charges.

Test conditions and individual results

The test ran on September 7, 2026 through SandBase API routes openai/gpt-6-astra and anthropic/claude-fable-5.1. Both received identical system and user messages with a 40,000-token output ceiling. Reasoning controls, temperature, and seed were omitted, leaving each route’s defaults in effect. Matching fields does not establish equal internal compute.

The games used Three.js 0.180.0 and ran in Chrome on the same machine. Functional checks used the requested test interface to inspect state and exercise objectives and collision. The separate keyboard traversal read coordinates and state but did not invoke teleportation, door-opening, or victory methods. Original game source was unchanged. Keyboard routes used mechanism positions inspected from source. Fable’s third version required routing around the central apparatus in its second room after the initial route hit it; no game code was changed.

The corresponding product entries are GPT-6 Astra and Claude Fable 5.1, checked September 8, 2026. Confirm the model IDs, selected endpoint’s schema, and current prices before a new run. The pages provide model access—not the browser, game artifacts, or functional checker used here.

These requests used an API, not Cursor. If you plan to use the models inside that editor, first check Cursor’s OpenAI access and BYOK limits. API access does not establish that the editor offers the same models or tools.

For a comparable new experiment:

1. Save one system message and one complete Aster Vault brief, including the controls and progression above; reuse both unchanged across models. This summary is not the full original request payload, so a newly written brief produces a new experiment, not an exact rerun.
2. Match the 40,000-token output ceiling using the selected endpoint’s documented field. Leave reasoning, temperature, and seed unspecified as in this test; record the endpoint and effective defaults, which may change over time. Do not mix Responses, Messages, and Chat Completions parameters.
3. Save every first response before opening it. Use the same Chrome environment and Three.js version; check startup, progression, closed-door collision, and reset without repairing files before scoring.
4. Log reception deadlines, missing responses, elapsed time, and all charges. Keep supplemental requests separate instead of replacing a timeout with a later success.

These steps describe a new comparison, not an additional test performed for this update. Model-page visibility does not verify a particular account’s access or guarantee the historical results.

Request	Response time	SandBase API charge	Result
Astra 1	151 s	$0.37330	Functional checks, keyboard completion, and reset passed
Astra 2	189 s	$0.45315	Same
Astra 3	195 s	$0.42480	Same
Fable 1	253 s	$1.14862	Initialization failure
Fable 2	Reception timeout around 300 s	$1.41582	No captured code; quality unknown
Fable 3	294 s	$1.28817	Functional checks, keyboard completion, and reset passed
Fable 4, supplement	272 s	$1.19942	Same

The supplement changed only the receiving deadline from 300 to 600 seconds, not the prompts or model parameters. Astra’s three captured responses totaled $1.25125; Fable’s three totaled $3.63621. An earlier Astra response lost during an interrupted collection session cost $0.41080 and was not scored. Including that loss and Fable’s timed-out response, this rerun cost $6.71408, excluding earlier testing.

For the day-to-day budget question, see GPT-6 Astra’s Plus usage limits and real API costs, which separates per-generation charges from subscription allowances.

Generating a 3D game and navigating one test different abilities. Our Astra multimodal and spatial reasoning review examines MazeBench’s 14% result alongside creator-reported CAD and visualization examples.

For Fable’s official benchmarks, cache-read prices and API ID, see the Claude Fable 5.1 overview. This test measured first responses, not whether an agent could diagnose the error and repair its own game. That different question needs the long-running task acceptance checks.

FAQ

Does this rank the models’ overall coding ability?

No. It tests one small game task and first-pass generation, not multi-round debugging after executing the code. The Fable supplement remains separate from the original batch’s unknown result.

Does “playable” mean better graphics or a more enjoyable game?

Here it means the specified controls and progression can be completed. There was no blind visual comparison, stable-frame-rate benchmark, or player-experience study. Mobile devices, other browsers, and large scenes were not covered.

Are these the providers’ official prices?

No. They are actual SandBase API request charges. The averages include the code that failed to start but exclude the two requests whose code was not captured. Both excluded charges remain in the total expenditure noted above.

Updated September 9, 2026: clarified the test’s SandBase attribution and links to Fable pricing and long-task evaluation. The experiment date, original outputs, request charges and scores are unchanged; no new test was run for this update.