GPT 6.2 Astra Review: I Built 5 Apps to Test It

GPT 6.2 Astra Review
Listen to this article· AI-generated voice

GPT 6.2 Astra Review: I Built 5 Apps to Test It

0:0041:34
onyx

OpenAI released GPT 6.2 Astra on 17 November 2026 and claims it builds better looking frontends, follows slide templates and handles CAD work.

So I gave it five hard builds at extra high reasoning effort: a physics climbing game, a wildfire simulator, a 3D architecture website, an AI slide deck builder and a parametric CAD app. Then I tested every app, checked every claim in its README files and scored each one out of 5.

Astra finished with 21.1 out of 25, and in this review you get every prompt I used, every score and the problems I found.

Key Takeaways

  • GPT 6.2 Astra scored 21.1 out of 25 across my five builds, with a top score of 4.5 for the Atrium website and a low of 3.8 for the Holdfast climbing game.
  • Astra is strongest at engineering: a CAD app with a working constraint solver, a deterministic fire model and valid PowerPoint and STL exports all held up in my tests.
  • Its weakest area is physical feel and tuning, like a climber that moves like a guided puppet and a fire model where wind shrinks the burned area.
  • I found no false claim in any README or help screen, even though OpenAI's system card says Astra hid known obstacles in 22.28 percent of one test.
  • Astra costs the same per token as Claude Fable 5.2, but Artificial Analysis measured $4.00 per task against $26.54 for Fable, while Fable still scores higher overall.
  • Astra is not in the regular ChatGPT Chat view. You get it in ChatGPT Work, Codex and the API.
  • What Is GPT 6.2 Astra?

    Screenshot 2026-11-18 at 19.44.17.png

    GPT 6.2 Astra is OpenAI's frontier model for hard, long projects. OpenAI launched it on 17 November 2026 together with GPT 6.2 Sol, a cheaper model for everyday work.

    OpenAI pitches Astra at professional output: slides, spreadsheets, documents, frontends, 3D scenes and CAD work. The launch post says it builds better looking frontends and follows slide templates more closely, which is exactly what my five builds test.

    GPT 6.2 Astra Specs at a Glance

    SpecGPT 6.2 AstraGPT 6.2 Sol
    API model IDgpt-6.2-astragpt-6.2-sol
    Context window1,050,000 tokens1,050,000 tokens
    Max input / output922K / 128K922K / 128K
    Knowledge cutoff18 May 20261 June 2026
    Input and outputText and image in, text outText and image in, text out
    Price per 1M tokens$8 in, $0.40 cached, $40 out$2 in, $0.10 cached, $10 out
    Above 272K input tokensInput and cache 2x, output 1.5xInput and cache 2x, output 1.5x

    Two pricing details matter for builders. Batch costs half, fast mode costs double, and Ultrafast costs 3 times the standard rate until 28 February 2027, then 6 times.

    Where You Can Use It

    In ChatGPT, Astra and Sol live in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users. The ChatGPT release notes say the rollout does not add either model to regular Chat.

    Developers get both models in the API. OpenAI's latest model guide says tool calling needs the Responses API, suggests starting new integrations at medium effort, and asks you to keep the prompt prefix unchanged so caching and reasoning carry over.

    How I Tested GPT 6.2 Astra

    I wrote one long prompt for each app. Every prompt names the stack, lists every system I want, and ends with a VERIFY checklist. Every prompt also ends with the same instruction: finish everything, then list honestly anything you did not finish, anything that does not work and anything you did not verify.

    I built all five apps with GPT 6.2 Astra at extra high (xhigh) reasoning effort. The Artificial Analysis table further down shows why. Xhigh scores the same as max on their index but finishes a task in about 6.5 minutes instead of 11.5.

    Then I tested each app in five ways:

  • Click through: I opened every app in a headless Chromium browser, used every screen I could reach and logged any errors.
  • Measure the VERIFY list: I scripted every checklist item a script can measure. For Fireline I pulled the fire model out and ran it in Node. For Podium I unzipped the PowerPoint file and read its XML.
  • Run the app's own tests: Two builds shipped test suites, and I ran them.
  • Read the code: Some things a browser cannot show you, such as how many WebGL contexts a page creates or how a solver handles conflicts.
  • Honesty check: I compared every claim in the README files and help screens with what I actually found.
  • Two limits matter. My test browser used software rendering, so frame rates meant nothing there, and I judged performance from the code instead.

    I also did not sign in to OpenAI from inside Podium or Datum, so their live AI features are untested. I checked their AI code and the mock tests they shipped.

    Each prompt comes with five rubric lines. I scored each line out of 5 and averaged them to get the app's score.

    My GPT 6.2 Astra Scoreboard

    #AppWhat it isEffortScoreMy verdict
    1HoldfastPhysics climbing gamexhigh3.8/5Every system works, but the body feels steered
    2Fireline3D wildfire simulatorxhigh4.2/5Real, testable fire model that needs tuning
    3AtriumSix page architecture websitexhigh4.5/5The best looking build, with smart 3D engineering
    4PodiumAI slide deck builderxhigh4.2/5Carefully tested, exports work, template fidelity unproven
    5DatumParametric CAD appxhigh4.4/5A real constraint solver and watertight parts
    Total21.1/25Strong engineering, weaker physical feel

    All five apps loaded with zero console errors in my test browser.

    Build 1: Holdfast, the Physics Climbing Game (3.8/5)

    0:00 / 0:00

    Holdfast was the first build, and it is the hardest kind of game to fake. You control each of the climber's hands with a separate mouse button, and the body has to hang, swing and fall under real gravity. Astra had to write all the physics itself, with no physics engine.

    The Prompt I Used

    I ran this prompt on GPT 6.2 Astra at xhigh effort.

    AI Prompt
    Build "Holdfast": a third-person physics climbing game. The player controls a climber's two hands
    separately and climbs procedurally generated rock faces to the summit. Every movement is physical:
    the body hangs, swings, and falls under real gravity. ONE self-contained holdfast.html.
    All geometry, textures, and audio procedural. Modern three.js via importmap:
    <script type="importmap">
    { "imports": {
      "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js",
      "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/"
    }}
    </script>
    Use SRGBColorSpace, ACESFilmicToneMapping, no deprecated APIs. EffectComposer + bloom + SSAO allowed.
    Write the physics yourself, no physics engine.
    
    ═══════════ THE CLIMBER (the core: get this right first) ═══════════
      - A ragdoll skeleton of particles joined by distance constraints: head, torso, pelvis, two
        two-segment arms, two two-segment legs. Verlet integration, fixed timestep (240Hz), several
        constraint iterations, and joint angle limits so elbows and knees only bend the right way.
      - CONTROLS: hold LEFT mouse button = left hand grips; hold RIGHT = right hand grips. Moving the
        mouse moves the free hand's reach target (limited by arm length). A gripping hand becomes a fixed
        point; the rest of the body hangs from it and SWINGS.
      - Let go with both hands and you fall. Hang by one hand and you swing like a pendulum.
      - FEET find footholds automatically: two-bone inverse kinematics places each foot on the nearest
        good foothold within reach. Feet planted on the rock take weight off the arms.
      - SPACE = DYNO: a lunge toward the aimed hold. Grab it in a short timing window or fall.
      - Render the climber as a smooth stylized figure (capsules around bones, a helmet, a chalk bag),
        animated by the physics skeleton.
    
    ═══════════ STAMINA & HOLDS ═══════════
      - Each arm has a grip stamina ring. It drains while gripping, faster when hanging by one arm,
        on overhangs, with no feet planted, or on poor holds, and refills slowly on good holds with
        feet planted. Empty = that hand lets go.
      - CHALK (C): refills grip a little, limited uses, a white puff on the hand.
      - HOLD TYPES generated on the rock, each readable at a glance:
          JUG (deep, easy) · CRIMP (thin edge, drains fast) · SLOPER (round; slips unless the body hangs
          below it) · POCKET · CRACK (jam a hand in) · LOOSE (crumbles a few seconds after you grab it)
          · ICE (slippery, alpine route only)
      - Subtle chalk smudges on holds so the route is readable without arrows.
    
    ═══════════ THE ROPE ═══════════
      - Place a PITON (P) at your current position (limited supply). Your rope runs to the last piton.
      - The rope is a Verlet chain with collision against the rock. When you fall, it catches you
        at the right length and you SWING into the wall, the pendulum and the impact are the drama.
      - FREE SOLO mode: no rope. A fall is the end of the run.
    
    ═══════════ THE MOUNTAIN ═══════════
      - Rock faces from noise-displaced geometry with cracks, ledges, overhangs, and chimneys.
        Detailed normal maps, ambient occlusion in the cracks, distinct rock per route.
      - The world below matters: as you climb, the valley, forest and river drop away, clouds pass
        BELOW you, and the horizon opens up. Looking down should be a little frightening.
      - FOUR ROUTES:
          1. SEA CLIFF at sunrise, sea spray, gulls, waves crashing far below
          2. GRANITE WALL at midday, long cracks, heat haze, a big overhang near the top
          3. ALPINE FACE in the afternoon, snow, wind gusts that push the body, cold that drains grip
          4. ICE LINE at night, a headlamp is your only light, ice holds, stars above
      - WIND: gusts visibly sway the body and the rope, with a warning sound just before.
      - Each route ends at a summit with a camera pull-back revealing the whole mountain.
    
    ═══════════ CAMERA & HUD ═══════════
      Third-person camera that keeps the climber and the next holds in frame, with mouse-wheel zoom and
      a "look down" key that slowly dollies out to show the drop. HUD kept minimal: two stamina rings
      near the hands, altitude, pitons left, and a route timer.
    
    ═══════════ GAME STRUCTURE ═══════════
      Route select with grades, timer, fall count and best times saved in localStorage; a GHOST of your
      best run; a daily seeded route; a short tutorial on the first route teaching grip, swing, and feet.
    
    ═══════════ AUDIO (Web Audio, synthesized) ═══════════
      Wind (rising with height), breathing that gets heavier as stamina drops, chalk puffs, hands
      scraping rock, carabiner clinks, crumbling rock, the rope snapping taut, a calm music bed.
    
    ═══════════ VERIFY ═══════════
      □ Hanging by one hand swings naturally; letting go of both always means falling
      □ Feet plant on footholds and reduce stamina drain
      □ A crimp drains faster than a jug; a sloper slips when grabbed from the wrong angle
      □ A loose hold crumbles after a few seconds
      □ The rope catches a fall at the right length and swings you into the wall
      □ A dyno only connects within its timing window
      □ The body never jitters, stretches, or passes through the rock
      □ 60fps at High on all four routes
    
    Finish every system in this response. When you're done, list honestly anything you did not
    finish, anything that doesn't work as specified, and anything you did not verify. Do not say a
    feature works unless you checked it. Output the complete single HTML file, no truncation.

    What Astra Built

    Astra delivered one HTML file of 5,022 lines and about 580 KB. It loads three.js through the importmap as asked, and it also tucks a compressed copy of three.js inside the file as a fallback. If the CDN is slow or you open the file offline, the game still starts.

  • A climber built from particles with Verlet physics at a fixed 240 Hz step, written from scratch
  • Four routes with their own scenery and grades: Sea Cliff at sunrise, Granite Wall at midday, Alpine Face in the afternoon and Ice Line at night
  • Seven hold types (jug, crimp, sloper, pocket, crack, loose and ice) with different shapes and chalk marks
  • Five pitons per climb, a rope, a free solo mode, chalk, a dyno and a look down key
  • Ghost runs of your best climb, a daily seeded route, best times saved in localStorage and a short tutorial on the first route
  • Synthesized audio for wind, breathing, chalk, rope and a calm music bed
  • Extras I did not ask for: Z and X as keyboard grips, touch buttons, an R key to climb the rope back to your piton, and the same two test hooks Fireline has
  • The route select screen looks like a real indie game menu, with an illustrated card for each route. In the climb, the art is stylized and low poly, with a clean HUD of stamina rings next to each hand.

    What Worked

    I drove the climber with real mouse input and with scripts that read the physics state. Every mechanic I probed behaved as the VERIFY list asked.

  • Body integrity: Across a 110 move scripted climb, a pendulum test and a fall, the bones never stretched and no part of the body passed into the rock.
  • One hand swing: With the feet off the wall, a one hand hang on a jug swung like a damped pendulum with a period of about 2.5 seconds.
  • Letting go: Releasing both hands always meant a fall, with the rope and in free solo.
  • Feet: Two planted feet turned stamina drain on a jug into a slow refill. With no feet and one hand, the grip drained.
  • Hold types: With both feet planted, a jug slowly refilled my grip while a crimp drained it. A sloper refused my grab when my hips sat above it and slipped when the body swung sideways.
  • Loose hold: It crumbled 2.85 seconds after I grabbed it, with dust and a sound.
  • Rope catch: I climbed past a piton and let go. The climber fell about 6.3 m, the rope caught exactly at its paid out length of 3.5 m, and the body swung back into the wall.
  • Dyno: A lunge could only catch the target hold between 0.085 and 0.52 seconds into the jump.
  • The sense of height works. Hold the look down key and the camera pulls up and out until the valley, river and rope fall away below you. Ice Line is the most atmospheric route, with stars overhead and a headlamp that lights only the rock right in front of you.

    What Did Not Work

  • The ragdoll is assisted. Astra holds the torso in shape every step and adds lift and support forces. The climber moves more like a guided puppet than a free ragdoll, and a one hand hang with feet planted barely swings.
  • The rope is simple. It has one anchor, so a second piton replaces the first instead of adding to the rope line. The catch is instant, with no stretch.
  • The rock is a height field. That rules out real chimneys and caves, and every route uses the same ladder style hold layout. The routes differ mostly in scenery and hold mix.
  • Shallow special holds. Cracks have no hand jam, ice holds only drain faster instead of slipping, and alpine cold is just a 1.2 times drain multiplier.
  • No post processing. There is no bloom or ambient occlusion pass, so the cracks rely on baked shading.
  • Untested: audio by ear, touch controls and a full human ascent. I confirmed the summit camera and results screen by moving the climber to the top with a script.
  • Did Astra Tell the Truth?

    Holdfast ships no README. The in game Field guide lists the controls and hold rules, and everything I tested matched it. The only stretch is the ice hold, which the guide says gives "little purchase", when in practice it only drains grip faster.

    My Score: 3.8 out of 5

    Rubric itemScore
    Climbing physics feel (swing, grip, falls)3.5
    Feet IK and stamina4.0
    Rope and pitons3.5
    Mountain visuals and sense of height4.0
    Routes, audio and polish4.0
    Overall3.8

    Holdfast is a complete, good looking climbing game with every system in place. It loses points where the prompt mattered most: the body feels steered, not hung.

    Build 2: Fireline, the 3D Wildfire Simulator (4.2/5)

    0:00 / 0:00

    Fireline is a science test dressed up as a game. I asked for a wildfire simulator where wind, slope, fuel and moisture drive the fire, and where you fight it with firebreaks, backburns and aircraft. Every rule in a spread model like this can be measured, so Astra cannot hide behind nice flames.

    The Prompt I Used

    I ran this prompt at xhigh effort. "The importmap above" means the three.js importmap from the Holdfast prompt.

    AI Prompt
    Build "Fireline": a 3D wildfire simulator. A fire spreads across a real-looking landscape, driven by
    wind, slope, fuel and moisture. The user starts fires, changes the weather, and fights them with
    firebreaks, backburns and aircraft, and watches whether the town survives. ONE self-contained
    fireline.html. Modern three.js via the importmap above. All procedural.
    
    ═══════════ THE LANDSCAPE ═══════════
      - Terrain about 3 km × 3 km from multi-octave noise: hills, a deep canyon, a ridge, a river,
        roads, and a small town at one edge.
      - A FUEL MAP that follows the terrain logically: grass on open slopes, shrubland, conifer forest,
        deciduous forest, bare rock on peaks, water. Instanced trees and shrubs that match it.
      - A moisture map: wetter near the river and in valley bottoms, drier on south-facing slopes.
    
    ═══════════ THE SPREAD MODEL (the heart) ═══════════
      Simulate on a grid (256² default, 512² option). Each cell has fuel type, fuel load, moisture,
      and a state: unburned → igniting → flaming → smouldering → burned out.
      Spread rate into a neighbour depends on, at minimum:
      - WIND: spread is much faster downwind, producing a long narrow elliptical fire shape
      - SLOPE: fire runs UPHILL far faster than downhill (it preheats the fuel above it)
      - FUEL: grass burns fast and briefly, forest slowly and intensely
      - MOISTURE and HUMIDITY: wet fuel resists ignition; above a threshold it won't burn at all
      Base the factors on the ideas behind the Rothermel spread model (wind and slope multiply a base
      rate). It doesn't need to be exact; it must behave right.
      - SPOTTING: intense fire lofts embers that land downwind and start new spot fires ahead of the
        front, the reason fires jump rivers and roads.
      - CROWN FIRE: in forest, when intensity is high enough, fire climbs into the canopy and moves much
        faster and hotter.
      - Deterministic for a given seed, so a scenario replays identically.
    
    ═══════════ THE VISUALS ═══════════
      - The fire front as a glowing, flickering line on the terrain, with instanced flame sprites whose
        height follows fire intensity
      - A huge SMOKE PLUME rising from the fire, leaning with the wind, lit orange from below, casting a
        shadow on the land
      - Ember particles streaming downwind
      - Burned areas darkening to black ash, then grey; smouldering spots glowing
      - Heat shimmer near the front; the sky turning orange-brown under heavy smoke
      - NIGHT MODE where the fire lights up the smoke and the terrain around it
    
    ═══════════ FIGHTING THE FIRE ═══════════
      - IGNITE: click to drop a lightning strike
      - FIREBREAK: draw a line where a bulldozer clears the fuel (takes time to cut)
      - BACKBURN: light a controlled fire to burn the fuel ahead of the main front, risky if the wind
        shifts
      - AIR TANKER: drop a line of pink retardant that slows the fire for a while
      - HELICOPTER: water drops on hot spots
      - In SCENARIO mode these have a budget and cooldowns; in sandbox they're unlimited
      - WEATHER CONTROLS: wind speed and direction, humidity, temperature, plus a scripted WIND SHIFT
        that suddenly turns the fire's flank into its head
    
    ═══════════ DATA & TOOLS ═══════════
      - PROGRESSION MAP: coloured contour lines showing where the fire's edge was at each hour, the way
        real wildfire maps are drawn
      - Live stats: area burned, rate of spread, perimeter, containment %, structures threatened and lost
      - Charts in hand-written SVG: area burned over time, spread rate over time
      - OVERLAYS: fuel type, moisture, slope, wind field, fire intensity
      - Time controls: pause, 1× to 60× speed, and a time-lapse replay of the whole fire
      - A short explainer panel for each factor (why uphill is faster, what spotting is)
    
    ═══════════ SCENARIOS ═══════════
      1. Grass fire in strong wind, learn how fast a wind-driven fire moves
      2. Canyon run, a fire racing uphill
      3. Ember storm, spot fires jump the river toward the town
      4. Backburn, protect the town with a controlled burn before the front arrives
      5. Wind shift, hold the line when the wind turns
      Each with a goal (protect the town, contain within X hectares) and a score. Plus sandbox.
    
    ═══════════ VERIFY ═══════════
      □ With no wind on flat ground, the fire spreads in a rough circle
      □ Wind stretches it into an ellipse pointing downwind
      □ Fire runs visibly faster uphill than downhill
      □ Wet fuel near the river resists burning
      □ A firebreak stops a low-intensity front but spot fires can jump it when intense
      □ Retardant slows spread for a while, then wears off
      □ A wind shift turns the fire's side into its leading edge
      □ The hourly progression contours match what actually burned
      □ Same seed, same fire
      □ 60fps at the 256² grid with full smoke and flames
    
    Finish every system in this response. When you're done, list honestly anything you did not
    finish, anything that doesn't work as specified, and anything you did not verify. Do not say a
    feature works unless you checked it. Output the complete single HTML file, no truncation.

    What Astra Built

    Astra delivered one HTML file of 915 lines and about 890 KB. It packed three.js and the fonts into the file itself, so Fireline runs offline without any CDN. The prompt pointed to the CDN, so this is a small deviation, but a useful one.

    Here is what sits inside that one file:

  • A procedural valley about 3 km across, with Cinder Ridge, a gorge, the Cedar River, roads and a 20 building town called Pinehaven
  • A fire grid of 256 by 256 cells, with a 512 option in the settings
  • About 85,000 instanced trees and shrubs that follow the fuel map
  • Five tools with a 100 credit budget and cooldowns: ignite, firebreak, backburn, air tanker and helicopter
  • Six scenarios (my five plus a sandbox), each scored out of 1,000
  • Overlays for fuel, moisture, slope, wind and intensity, hand drawn SVG charts, hourly contours and a replay
  • Astra also added two test hooks I never asked for: render_game_to_text() and advanceTime(). A script can read the game state and fast forward time with them, which made my testing much easier.

    What Worked

    I pulled the spread model out of the file and ran it on its own in Node, so I could measure the fire instead of eyeballing it. It passed 8 of the 9 VERIFY checks I could run.

  • Calm, flat ground: The fire grew in a near perfect circle. After 20 minutes the widest radius was only 1.05 times the narrowest.
  • Slope: On a moderate slope, the fire ran 2.4 times farther uphill than downhill in 15 minutes. On the steepest test slope, the downhill side almost stopped.
  • Moisture: Fuel next to the river stayed too wet to ignite, and no water cell ever burned.
  • Firebreak: A grass fire stopped dead at the break. A conifer crown fire at 45 km/h threw 140 spot fires and jumped it, exactly as the prompt asked.
  • Retardant: The pink line held the front for its full 30 minutes, then the fire moved on at the exact moment it expired.
  • Wind shift: After the wind swung south, the fire gained 398 m to the south against 176 m to the east. The old flank became the head.
  • Contours: The 1 hour contour matched my independent count of the burn edge exactly, 558 segments for both.
  • Same seed, same fire: Two runs produced identical state hashes. The replay also repeated my tool drops and ended in the same state as the original run.
  • The visuals are the best part. The forests look like real conifer and broadleaf stands, burned ground cools from black to grey, the pink retardant reads clearly from above, and night mode lights the land orange around the fire.

    What Did Not Work

    Fireline passes the shape tests, but some numbers feel wrong once you play with it.

  • Wind makes fires smaller. With no wind, a grass fire burned 94 hectares in 20 minutes. At the default 22 km/h it burned only 44 hectares. The head runs faster, but the wind term crushes the flanks and the back so hard that the total area drops.
  • The ellipse is weak at default wind. The length to width ratio is 1.06 at 22 km/h, more egg than ellipse. The fire only gets long and narrow near 42 km/h, where the ratio reaches 1.75.
  • Containment is generous. A fire nobody touched reads 39 to 56 percent contained after one or two hours, because burned out edges count as contained.
  • Losing still scores well. A failed scenario with no buildings lost and unspent credits scores 700 out of 1,000.
  • The scripted wind shift lives in one scenario. In the sandbox, the wind shift button only moves a slider, and you still press Apply.
  • Crown fire hides at default weather. It needs wind above 26 km/h, so a casual player at the default 22 km/h never sees it.
  • Slow start. The page took about 35 seconds to load in my software renderer, because it builds a large tree texture on the main thread. A real GPU machine should load faster.
  • Did Astra Tell the Truth?

    Fireline ships no README, so I checked the in app Field guide instead. It makes specific claims about threatened structures, the scoring split and how replay works, and every claim I tested held up.

    My Score: 4.2 out of 5

    Rubric itemScore
    Spread behavior (wind, slope, fuel, spotting)4.0
    Fire and smoke visuals4.5
    Firefighting tools and wind shift4.5
    Data and progression map4.0
    Scenarios and polish4.0
    Overall4.2

    Fireline is a real simulator, not a pretty fire shader. It needs a retune of the wind term, the containment metric and the scoring before I would hand it to a classroom.

    Build 3: Atrium, the Architecture Studio Website (4.5/5)

    0:00 / 0:00

    OpenAI says Astra builds better looking frontends, so I gave it a hard frontend. Atrium is a six page website for an architecture studio, built around real 3D buildings and real sunlight, with scroll animation on almost every section.

    The Prompt I Used

    I ran this prompt at xhigh effort. "The importmap above" again refers to the three.js importmap from the Holdfast prompt.

    AI Prompt
    Build "Atrium": the website for an award-winning architecture studio. A complete MULTI-PAGE site:
    6 interlinked pages, one design system, one nav, transitions between pages. IMMERSIVE and
    ANIMATION-HEAVY, built around real 3D buildings and real sunlight.
    
    STACK: three.js via the importmap above (three@0.170.0, modern API only), GSAP 3.12 +
    ScrollTrigger, Lenis smooth scroll, Lucide icons, Google Fonts. All imagery procedural.
    
    FILES:
      shared.css · shared.js
      index.html · projects.html · project.html · studio.html · research.html · contact.html
      js/home.js · js/projects.js · js/project.js · js/studio.js · js/research.js · js/contact.js
    
    DESIGN DIRECTION: "light as material":
      Light-first. Architectural white, warm concrete greys, black ink, and ONE accent (a warm
      terracotta). A precise grotesk for display, a clean sans for body, a mono for coordinates,
      dimensions and sun angles. A strict 12-column grid, generous whitespace, thin rules. Calm,
      exact, confident.
    
    THE BUILDINGS (procedural, shared by every page):
      Build 5 distinct procedural buildings from code: cantilevered concrete volumes, a timber
      pavilion, a glass tower with a fin facade, a museum with a stepped roof, and a house cut into a
      slope. Real materials: board-marked concrete, timber, glass with reflections, soft shadows,
      ambient occlusion, an environment map. Each sits on a simple landscaped site.
    
    CUSTOM CURSOR: a small cube that casts a soft shadow onto the page. The shadow's direction follows
      the page's current sun angle (on the homepage it moves with the scroll; elsewhere it's a fixed
      late-afternoon sun). On hover over links the cube rotates flat into a square. Hidden on touch.
    
    PAGE TRANSITIONS: a SECTION CUT: a thin plane sweeps across the screen like a cutting plane
      slicing a model, revealing the next page behind it.
    
    ═══════════ PAGE 1: index.html ═══════════
      - HERO: the studio's signature building in real 3D on a plinth, slowly rotating, mouse parallax,
        the studio name set large.
      - INTERLUDE 1: "A DAY OF LIGHT" (pinned, ~400vh): the camera holds on the building while the sun
        moves from dawn to dusk as you scroll. Shadows sweep across the facades, light from a skylight
        moves across the atrium floor (shown in a cutaway), the sky colour changes, and at night the
        interior lights come on with a few small figures inside. A mono readout shows time, sun
        azimuth and altitude.
      - INTERLUDE 2: "FROM SITE TO BUILDING" (pinned): the land's contour lines appear, simple massing
        blocks rise, a structural grid of columns and slabs builds up, facade panels click into place,
        and trees grow around it.
      - Selected projects (3, each a live 3D thumbnail), the studio's approach in three principles,
        awards and press, a quote from the founding partner, and a contact CTA. 11+ sections total.
    
    ═══════════ PAGE 2: projects.html ═══════════
      A filterable grid (residential, cultural, civic, workplace, landscape). Each card shows a live 3D
      massing model that rotates on hover. Render all thumbnails with ONE shared WebGL renderer using
      scissor/viewport regions, not one WebGL context per card. A map view of project locations.
    
    ═══════════ PAGE 3: project.html (detail, ?id=…) ═══════════
      - An orbitable 3D model of the building
      - A SUN STUDY: sliders for date and time of day that move a correctly-angled sun and real shadows
        (use a simple solar-position calculation from latitude, date and hour)
      - A floor plan (SVG) linked to the model: hover a room on the plan and it highlights in 3D, and
        vice versa
      - A SECTION toggle that cuts the building open with a clipping plane
      - The story, materials list, drawings (procedural SVG plans and elevations), credits, next project
    
    ═══════════ PAGE 4: studio.html ═══════════
      Partners and team (hover reveals a short bio), the studio's process as a sequence that draws on
      scroll, a timeline of key projects, awards, and open positions.
    
    ═══════════ PAGE 5: research.html ═══════════
      Material and sustainability research: an embodied-carbon comparison chart (timber vs concrete vs
      steel, SVG), a DAYLIGHT HEATMAP over a floor plan that updates with a time-of-day slider, and short
      research articles.
    
    ═══════════ PAGE 6: contact.html ═══════════
      A validated project enquiry form, studio locations with live local-time clocks, and a closing 3D
      shot of a building at golden hour.
    
    SHARED SYSTEMS (shared.js): Lenis + a thin progress rule; the shadow-cube cursor; theme toggle
      (light/dark, dark shows the buildings at night) persisted in localStorage; [data-reveal]
      entrance system; subtle magnetic buttons; tilt cards; the section-cut page transition; the shared
      procedural building library and the single shared WebGL renderer.
    
    REQUIREMENTS: frosted nav after scroll, active page indicated, mobile overlay menu, fully responsive
      (fewer live 3D views on phones), reduced-motion respected (the day-of-light becomes a still
      sequence), accessible (semantic HTML, focus states, aria labels), 60fps target, pixel ratio capped
      at 2, a static fallback when WebGL is unavailable. Project names, locations and figures must match
      across every page.
    
    DELIVERY: shared.css and shared.js complete first, then each page with its JS. Finish every page in
    this response. When you're done, list honestly anything you did not finish, anything that doesn't
    work as specified, and anything you did not verify. Do not say a feature works unless you checked
    it. No truncation. End with a validation checklist.

    What Astra Built

    Astra built all six pages on one shared design system. The core files are shared.css at 1,555 lines, shared.js at 802 lines and a building library, models.js, at 698 lines.

  • Five procedural buildings made entirely from code, including Solstice House and Meridian Tower, with no model files and no texture loader
  • Local copies of three.js, GSAP, ScrollTrigger, Lenis and OrbitControls, so nothing loads from a CDN
  • A night version of every building for dark mode
  • A small Python server, server.py, that saves contact form enquiries to a SQLite database, which I never asked for
  • I submitted the contact form and got back a real reference number. That is a nice touch for a site that only needed a front end.

    What Worked

    The homepage interlude "A Day of Light" is the best single moment across all five builds. As you scroll, the sun moves from 05:01 at an azimuth of 63 degrees to 19:42, five degrees below the horizon.

    Shadows sweep across Solstice House, the cutaway shows the light moving across the floor, and at night the interior lights come on with small figures inside. A mono readout tracks time, azimuth and altitude the whole way.

    The second interlude, "From Site to Building", plays in five stages: contour lines, massing blocks, a structural grid, facade panels and finally the landscape.

    Astra also got the engineering right, and that was the part I worried about most.

    Every 3D page uses exactly one WebGL context. The projects grid draws every live thumbnail through one shared renderer with scissor and viewport regions, exactly as I asked. It only renders views that are on screen, and it only redraws shadows when something changes.

    The project page has three real tools:

  • Sun study: The sliders drive a real solar position formula. For Meridian Tower in Rotterdam at 51.92 degrees north, summer noon reads 61.5 degrees and winter noon 14.6 degrees, which matches the textbook result.
  • Linked plan: Hover a room on the SVG floor plan and it lights up in 3D. Hover the 3D model and the plan highlights the matching room.
  • Section cut: One toggle slices the building open with a clipping plane.
  • The basics hold up too. The theme toggle saves to localStorage and switches every building to its night version, and at 390 px wide there is no horizontal scroll.

    Reduced motion turns the day of light into a still sequence. With WebGL switched off, the site falls back to poster images with no errors.

    The contact form validates every field, the Kyoto and Rotterdam clocks tick, and project names and coordinates match on every page.

    What Did Not Work

  • "All imagery procedural" is only partly true. Astra shipped 13 prerendered .webp images (posters, night posters and three study stills) plus a world map SVG. Most serve as fallbacks, but a Dawn, Midday and Dusk strip on the homepage shows them as ordinary images.
  • Thin secondary pages. The research page's embodied carbon chart has just three bars of per kilogram factors for timber, concrete and steel, not a real comparison of projects. The studio page is fine but short.
  • Plan labels overlap. On Meridian Tower, "Work floor", "Core" and "Meeting room" collide, and every plan shows a single floor.
  • One star building. The hero and both interludes lean on Solstice House, so the homepage shows less variety than the five building library allows.
  • Did Astra Tell the Truth?

    The README claims hold: one shared renderer, local assets, carbon factors labeled as illustrative and a heatmap described as relative exposure. It also says the fallback stills come from the same geometry. They match the live renders, but I could not verify how they were made.

    My Score: 4.5 out of 5

    Rubric itemScore
    3D buildings and lighting quality4.5
    Day of light and site to building interludes5.0
    Project page (sun study, linked plan, section cut)4.5
    Multi page consistency and transitions4.5
    Completeness and performance4.0
    Overall4.5

    Atrium is the build I would show anyone who thinks AI websites all look the same.

    Build 4: Podium, the AI Slide Deck Builder (4.2/5)

    0:00 / 0:00

    Podium tests a claim straight from the launch post: Astra follows slide templates more closely. I asked for a web app that turns an outline into a designed deck, copies a brand template from screenshots, and exports to PowerPoint and PDF.

    The Prompt I Used

    I ran this prompt at xhigh effort.

    AI Prompt
    Build "Podium": a web app that turns an outline into a designed, presentable slide deck, follows
    a given brand template, and exports to PowerPoint and PDF.
    
    STACK: a tiny local Node/Express server (server.js) that holds the API key and forwards requests,
    plus a frontend in public/ (index.html, app.js, styles.css). PptxGenJS from jsdelivr for .pptx export.
    No frontend framework. Slides rendered as HTML/SVG at a fixed 16:9 (1920×1080) and scaled to fit.
    AI: OpenAI Responses API, model "gpt-6.2-astra", key from OPENAI_API_KEY in .env. Effort "xhigh" for
    generating a full deck, "medium" for single-slide edits. Use structured outputs (JSON schema) for every
    deck and slide response. Keep editing conversations append-only so the cached prefix is reused.
    
    ═══════════ THE SLIDE ENGINE ═══════════
      - LAYOUTS: title · section divider · bullets · two columns · big number · quote · chart ·
        timeline · image + text · comparison table · team grid · agenda · closing
      - A THEME: colours (background, text, accent ×2), a heading and body font pair (from a bundled
        Google Fonts list), margins, title placement, and an accent device (a rule, a corner block, a
        numbered marker)
      - TEXT FITTING: every text box has fixed bounds. Shrink text within a minimum size to fit; if it
        still doesn't fit, flag the slide as OVERFLOWING. Never let text spill off a slide.
      - CHARTS: bar, line, and donut drawn in SVG from data, styled by the theme
      - ICONS from Lucide; images can be dropped in by the user (no external image fetching)
    
    ═══════════ AI GENERATION ═══════════
      1. FROM AN OUTLINE: paste notes, an outline, or just a topic and audience. The model returns a deck
         as JSON: slides with layout, title, content, chart data where useful, and speaker notes.
         Validate it, unknown layouts dropped, text lengths checked, chart data numeric.
      2. FROM A TEMPLATE: upload 2 to 4 screenshots of an existing deck. Send them as images; the model
         returns a theme (colours, which fonts the screenshots most resemble from the bundled list,
         margins, title placement, accent device, how many words per slide the deck tends to use).
         Show the extracted theme for the user to confirm before generating.
      3. EDITS: select a slide and ask: "shorter", "turn this into a chart", "split into two slides",
         "more visual". Or ask for deck-wide changes: "make the whole thing 10 slides", "more formal".
    
    ═══════════ EDITING ═══════════
      Click any text to edit it in place, drag slides to reorder in the sidebar, change a slide's layout
      (content carries over), edit chart data in a small table, swap the theme live. Undo/redo.
    
    ═══════════ ANIMATION ═══════════
      - Build-in animations per element: fade, rise, wipe, scale, with order and delay
      - Slide transitions, including a MAGIC MOVE: elements with the same id on consecutive slides
        smoothly move, resize and recolour into their new position instead of cutting
      - Present mode plays everything
    
    ═══════════ PRESENT MODE ═══════════
      Fullscreen with keyboard navigation, plus a PRESENTER VIEW in a second window: current slide, next
      slide, speaker notes, a timer, and slide count.
    
    ═══════════ QA PANEL (design linting) ═══════════
      Flags any slide with: overflowing text, more than 40 words, contrast below WCAG AA, more than one
      heading size, off-theme colours, or an empty placeholder. Click a warning to jump to the slide.
    
    ═══════════ EXPORT ═══════════
      - PPTX via PptxGenJS with REAL editable text boxes (not images of slides), the theme's colours and
        fonts, charts as native charts where PptxGenJS supports it, and speaker notes
      - PDF at exact 16:9 via a print stylesheet
      - PNG per slide
    
    ═══════════ WITHOUT AN API KEY ═══════════
      Two sample decks already generated (a product launch and a quarterly review) so the editor, present
      mode, QA panel and exports all work with no key. Only generation and AI edits need one.
    
    ═══════════ VERIFY ═══════════
      □ No generated slide has text spilling off it
      □ A deck generated from template screenshots visibly matches them (colours, fonts, layout)
      □ Magic move animates matching elements between slides
      □ The PPTX opens in PowerPoint, Keynote and Google Slides with editable text and the right fonts
      □ PDF pages are exactly 16:9 with no clipped content
      □ The QA panel catches a deliberately overstuffed slide
      □ Presenter view stays in sync with the main window
    
    Finish every file in this response. When you're done, list honestly anything you did not finish,
    anything that doesn't work as specified, and anything you did not verify. Do not say a feature
    works unless you checked it. Output all files complete, no truncation, with a README covering setup.

    What Astra Built

    Podium is a small Express server plus a plain JavaScript editor of about 5,800 lines, split into modules. With its tests, the project runs to about 8,100 lines.

  • All 13 layouts I listed, a theme system with five bundled fonts, SVG bar, line and donut charts, and Lucide icons
  • Two sample decks that work with no key: Forma One, a product launch with 8 slides, and Northline, a quarterly review with 6 slides
  • Its own test suite: 6 Node tests and two browser test scripts
  • Extras beyond the prompt: a dashboard with a deck library, a theme library, and a second AI provider that lets you "Sign in with ChatGPT" through the Codex app server instead of pasting an API key
  • What Worked

  • Tests: All 6 Node tests passed. Both browser suites passed after I pointed them at a headless browser, which covered about 48 checks on editing, undo and redo, drag to reorder, layout and theme swaps, chart tables, the QA panel, the presenter view and exports.
  • Text fitting: I filled all 13 layouts with 400 to 1,800 characters of text. Zero elements left the slide, and 12 of the 13 layouts raised the OVERFLOWING flag. The quote layout flagged the word count instead.
  • QA panel: Pasting 150 words into a subtitle raised an overflow warning and a word count warning. Clicking the warning jumped straight to the slide, and both sample decks passed the linter clean.
  • Magic move: Titles smoothly change width, font size and color between slides.
  • Presenter view: The second window shows the current slide, the next slide, notes, a timer and "Slide 2 of 8". Moving forward in either window moves the other.
  • PowerPoint export: The Forma One file has 8 slides, 66 editable text runs, a native chart with its Excel data embedded, and 8 pages of speaker notes. A separate test file produced native bar, line and doughnut charts.
  • PDF export: 8 pages, each exactly 1440 by 810 points, which is 16:9.
  • The AI code path matches my prompt on every point I could check: model gpt-6.2-astra, xhigh for full decks, medium for single slide edits, a strict JSON schema, 2 to 4 screenshots for template extraction, and validation of every returned deck. Astra even wrote a test that confirms each request starts with the previous request byte for byte, which is how you keep the cached prefix.

    What Did Not Work

  • I could not test real generation. Generation and template extraction need an API key or a ChatGPT sign in, and I did not connect either for this review. I checked the code and the mock tests only.
  • Template fidelity has a ceiling. The extractor captures six style settings: palette, font, margins, title placement, accent device and word budget. It cannot copy a template's layout structure.
  • Tables are not native. The comparison table exports as text boxes and lines, not a PowerPoint table.
  • Theme colors stay default inside PowerPoint. Each slide uses the right colors, but the file's theme keeps PptxGenJS defaults, so swapping theme variants in PowerPoint will not recolor the deck.
  • Fonts are not embedded. The README tells you to install them and offers a font download.
  • Thin animation demo. The sample decks show build animations on one slide only.
  • I did not open the exports in PowerPoint, Keynote or Google Slides. I checked the file structure instead.
  • Did Astra Tell the Truth?

    Yes, and Podium's README has the most useful honesty note of the five. The README has an "Unverified externally" list that covers API billing, real template fidelity, cache hits, PowerPoint, Keynote and Google Slides, multiple monitors and browsers other than Chrome. That list matches exactly what I could and could not confirm, and every claim about the PowerPoint file held up when I unzipped it.

    My Score: 4.2 out of 5

    Rubric itemScore
    Deck design quality4.5
    Template fidelity3.5
    Text fitting and QA panel4.5
    Magic move and present mode4.5
    PPTX and PDF export that actually works4.0
    Overall4.2

    Podium is a polished, well tested tool. Template fidelity is the one score I want to retest once I connect a key.

    Build 5: Datum, the Parametric CAD App (4.4/5)

    0:00 / 0:00

    Datum is the hardest prompt of the five, and OpenAI lists CAD work as one of Astra's strengths. I asked for a parametric CAD app in the browser with a constraint solver Astra had to write itself, a feature tree that rebuilds when you change a dimension, real solid booleans and an AI that turns a description into an editable part.

    The Prompt I Used

    I ran this prompt at xhigh effort. "The importmap above" refers to the three.js importmap from the Holdfast prompt.

    AI Prompt
    Build "Datum": a parametric 3D CAD app in the browser. Draw 2D sketches with constraints, turn them
    into 3D with features like extrude and revolve, and edit any dimension later, every feature after it
    rebuilds automatically. An AI turns a description of a part into an editable feature tree.
    
    STACK: a tiny local Node/Express server (server.js) for the API key, frontend in public/.
    three.js for display (importmap above, three@0.170.0). manifold-3d from jsdelivr (WASM) for solid
    booleans. Write the 2D constraint solver yourself.
    AI: OpenAI Responses API, model "gpt-6.2-astra", effort "xhigh" for generating a part, "medium" for
    edits. Structured outputs (JSON schema) for every feature tree. Append-only edit conversations.
    
    ═══════════ SKETCHES & THE CONSTRAINT SOLVER ═══════════
      - Sketch on a base plane (XY, XZ, YZ) or on a flat face of the model
      - Tools: line, rectangle, circle, arc, polygon, slot, and 2D fillet and chamfer on sketch corners
      - CONSTRAINTS: coincident, horizontal, vertical, parallel, perpendicular, tangent, equal, fixed,
        distance, angle, radius
      - The SOLVER: express every constraint as an equation and solve them together iteratively
        (Newton or Gauss-Newton). Dragging a point keeps all constraints satisfied.
      - Show whether a sketch is under-constrained (blue), fully constrained (black) or
        over-constrained (red, with the conflicting constraints listed)
    
    ═══════════ FEATURES & THE FEATURE TREE ═══════════
      - EXTRUDE (blind, symmetric, up to a face; add or cut) · REVOLVE · HOLE (simple, counterbore,
        countersink) · LINEAR and CIRCULAR PATTERN · MIRROR · BOOLEAN between bodies
      - A FEATURE TREE in a sidebar showing every step in order. Click any feature to edit its
        parameters; everything after it regenerates. Drag to reorder; suppress a feature to test without it.
      - A PARAMETERS table: named variables with expressions (wall = 3, width = phone_w + 2*wall).
        Changing one value updates every feature that uses it.
      - If a feature fails to regenerate (a cut that no longer hits anything), mark it red with a
        reason and leave the rest intact, never crash the model.
      - Booleans run through manifold-3d, so solids stay watertight.
    
    ═══════════ VIEWING & ANALYSIS ═══════════
      Orbit/pan/zoom with a view cube, orthographic and perspective, edges drawn over faces, a SECTION
      view with a draggable clipping plane, a MEASURE tool (distance, angle, radius), and MASS
      PROPERTIES (volume, surface area, mass from a chosen material's density, centre of mass marker).
      A 3D-PRINT CHECK: confirms the mesh is watertight and warns about walls thinner than a set minimum.
    
    ═══════════ 🤖 THE AI ═══════════
      1. DESCRIBE A PART: "a phone stand angled at 70°, 8 mm thick, with a slot for a charging cable",
         "a wall bracket for a 25 mm pipe with two M5 screw holes", "a 20-tooth spur gear, module 2, with a
         6 mm D-shaft bore". The model returns a feature tree as JSON: named parameters, sketches with
         their geometry and constraints, and features that reference them.
      2. EDIT IN WORDS: "make it 10 mm taller", "add four M3 holes 5 mm in from each corner", "make the
         walls thinner". The model changes PARAMETERS and features, not raw geometry, so the part stays
         editable by hand.
      3. FROM A DRAWING: upload a photo of a dimensioned sketch or drawing; the model reads the
         dimensions and builds the part.
      VALIDATE everything: every reference points to something that exists, numbers are finite and
      within sane ranges, and the tree regenerates. If it doesn't, show which feature failed and offer
      to ask the model to fix that one feature.
    
    ═══════════ EXPORT ═══════════
      STL, 3MF and OBJ for 3D printing and other tools, the feature tree as JSON (re-importable), and a
      PNG screenshot.
    
    ═══════════ WITHOUT AN API KEY ═══════════
      Four sample parts with full feature trees, a phone stand, a pipe bracket, a spur gear, and a box
      with a snap-fit lid, so sketching, the solver, editing, analysis and export all work with no key.
    
    ═══════════ VERIFY ═══════════
      □ A constrained rectangle stays rectangular when you drag a corner
      □ Over-constraining a sketch is detected and the conflicting constraints are named
      □ Changing a parameter regenerates every dependent feature correctly
      □ A 10 mm cube reports exactly 1000 mm³ volume
      □ Exported STL is watertight and opens in a slicer (e.g. PrusaSlicer, Cura)
      □ A failed feature is marked red without breaking the rest of the model
      □ AI-generated parts come back as editable feature trees, not frozen meshes
      □ The four samples work with no API key
    
    Finish every file in this response. When you're done, list honestly anything you did not finish,
    anything that doesn't work as specified, and anything you did not verify. Do not say a feature works
    unless you checked it. Output all files complete, no truncation, with a README covering setup.

    What Astra Built

    Datum runs to about 10,200 lines, with roughly 1,400 of them in tests. It uses a small Express server, three.js for display and manifold-3d for solid booleans, exactly the stack I asked for.

  • A sketch editor with eight tools: line, rectangle, circle, arc, polygon, slot, fillet and chamfer
  • A constraint solver Astra wrote from scratch, with all 11 constraint types from the prompt
  • Extrude, revolve, three hole styles, linear and circular patterns, mirror and booleans
  • A parameters table that accepts expressions and detects circular references
  • Four sample parts that work with no key: a pipe bracket, a phone stand, a 20 tooth spur gear and a box with a snap fit lid
  • Extras beyond the prompt: a Workspace dashboard with a part library, and the same "Sign in with ChatGPT" option as Podium
  • The interface looks like a commercial CAD tool. You get a model browser and feature tree on the left, an inspector with parameters and materials on the right, a view cube, and dimensions drawn right on the model.

    What Worked

  • Tests: All 21 of Datum's own Node tests passed. Its browser suite passed 10 of 11 sections in my headless browser. The last section, which covers mobile panels and the no key AI setup, crashed my software rendered browser, so I count it as untested.
  • Solver: It is a real damped Gauss-Newton solver, as the prompt asked. I constrained a rectangle and dragged a corner, and it stayed exactly rectangular. When I added two different distances to the same edge, Datum turned the sketch red and named both conflicting constraints.
  • The 10 mm cube: It reports exactly 1,000 cubic millimeters of volume and 600 square millimeters of surface area. I computed the volume again from the exported STL and got 1,000.000.
  • Watertight exports: I checked the STL files for the cube and all four samples. Every edge is shared by exactly two triangles, and every exported volume matches what the app reports.
  • Failure isolation: I moved the pipe bracket's bore hole 500 mm off the part. That one feature turned red with the reason "Cut does not intersect the target body", and the other 9 features still rebuilt.
  • Parameters: Changing a parameter rebuilt every feature that depends on it.
  • Samples and exports: All four samples opened with zero failed features and zero page errors. STL, 3MF, OBJ, PNG and JSON downloads all worked, and the JSON imported back in.
  • The AI path matches the prompt on every point I could check in code and in the mock tests: gpt-6.2-astra, xhigh for new parts, medium for edits, a strict JSON schema, chained conversations and a repair flow that replaces only the failed feature. The schema describes a feature tree with no mesh field, so an AI part can only come back as editable features.

    What Did Not Work

  • I could not test live AI parts. Like Podium, the AI needs an API key or a ChatGPT sign in, so I do not know how well Astra itself writes constrained sketches for Datum.
  • No slicer test. The README says the STL opened in PrusaSlicer. My watertight checks passed, but I did not open the files in a slicer.
  • A strict solver. Redundant constraints that agree with each other still count as over constrained. That is a design choice, but a beginner may find it fussy.
  • A setup trap. If you set the cache folder to a relative path, the geometry engine fails to load and the app hangs on "Loading geometry kernel". The default setting works fine.
  • Dense code. The main app file chains long declarations together, which makes it hard to read and extend.
  • Did Astra Tell the Truth?

    Yes. The README has a limitations section that says live AI is not verified, the wall thickness check samples points, curves are tessellated and the solver has caps of 180 points and 120 features. Every claim I could check was true, including the exact 1,000 cubic millimeter cube and the edge checks on the STL files.

    My Score: 4.4 out of 5

    Rubric itemScore
    Constraint solver quality4.5
    Parametric rebuild4.5
    Solid modelling and export4.5
    Analysis tools4.5
    AI parts that stay editable4.0
    Overall4.4

    Datum is the build that surprised me most. I did not expect an AI model to hand me a working parametric CAD app with a solver it wrote from scratch.

    What My Five Builds Tell You About GPT 6.2 Astra

    Five apps is a small sample, but the same patterns showed up in every build.

    It Writes Code You Can Test

    Astra kept building ways to check its own work. Fireline and Holdfast expose functions that let a script read the game state and fast forward time.

    Podium and Datum ship real test suites, and 27 of 27 Node tests passed between them. I never asked for any of that, and it made every score in this review easier to verify.

    Its Honesty Notes Held Up

    I went in worried about the system card's honesty numbers, which I cover below. I compared every README, limitations list and help screen against what I found, and I did not catch a single false claim. Podium and Datum even listed the exact things I could not verify myself.

    It Gets the Engineering Right and Misses Some Tuning

    The hard parts held up everywhere: a solver, a deterministic fire model, a shared WebGL renderer, valid PowerPoint charts, watertight STL files. The misses sit at the tuning and finishing level, like Fireline's wind term and scoring, Atrium's thin research page and Podium's table export. That fits the VentureBeat reports of Astra stopping early, but in my builds the early stops landed on secondary features, not core systems.

    It Adds Features You Did Not Ask For

    Podium and Datum both gained dashboards and a "Sign in with ChatGPT" option. Atrium gained a database backed contact form, and Fireline packed three.js into the file so it works offline. Most of these extras help, but they also mean more code to review before you ship.

    Physical Feel Is Its Weakest Spot

    My lowest score went to the build that depends most on feel. Holdfast's climber passed every measurement, yet it moves like a guided puppet because Astra propped the body up with extra forces.

    Fireline has the same gap: the fire model passes the shape tests, but wind shrinks the total burned area. If your project lives or dies on how something feels in motion, plan for a round of tuning after Astra finishes.

    GPT 6.2 Astra Benchmarks: What the Independent Numbers Say

    OpenAI's launch post is full of wins. I care more about the independent leaderboards, so here is what they show as of 18 November.

    Artificial Analysis: Second Place, Much Cheaper Per Task

    Artificial Analysis puts Astra second on its Intelligence Index with 62, behind Claude Fable 5.2 at 65 and ahead of Gemini 4 Carbon at 60 and Claude Opus 5.5 at 59.

    The cost column changes the story. On the Artificial Analysis leaderboard, Astra at max effort costs $4.00 per task against $26.54 for Fable 5.2, so Fable costs about 6.6 times more per task.

    EffortIndex scoreMinutes per taskOutput tokens per index run
    Max6211.565.8M
    Xhigh626.527.1M
    High605.120M
    Medium573.812.4M
    Low461.56.31M

    Source: Artificial Analysis model page for GPT 6.2 Astra, accessed 18 November 2026.

    This table is why I ran every build at xhigh. Xhigh scores the same 62 as max, but max takes about 77 percent longer and uses 2.4 times the output tokens.

    3D, Coding and Science

  • 3D: On Artificial Analysis's human judged AA-3D test, Astra leads with 1,318 Elo, ahead of Fable 5.2 at 1,271.
  • Web apps: On Vals Vibe Code Bench, Astra scores 89.9 percent and ranks eighth, while Fable 5.2 leads at 93.77 percent. Astra's run cost $7.92 against $22.13 for Fable.
  • Terminal work: On Vals Terminal-Bench 4.0, Astra scores 63.13 percent against 65.15 percent for Fable 5.2.
  • Science: On Vals Terminal-Bench-Science, Astra ranks first at 71.43 percent, far ahead of Fable 5.2 at 55.71 percent.
  • Overall Vals Index: Astra ranks seventh at 67.7 percent, behind Fable 5.2 at 71.3 percent.
  • Puzzles: On the ARC Prize leaderboard, Astra scores 95.8 percent on ARC-AGI-2 but 70.3 percent on the ARC-AGI-3 standard harness, where Fable 5.2 scores 81.2 percent. The 100 percent headline you may have seen uses a provider adapter harness.
  • The Honesty Problem in the System Card

    OpenAI's GPT 6.2 system card contains the most useful number for anyone who builds with Astra. In a test where the model hits a known obstacle, Astra left the obstacle out of its report in 22.28 percent of trials, double the 11.09 percent of GPT 6 Astra.

    In a broken search tool test, Astra failed the task 23 percent of the time against 7.58 percent for GPT 6 Astra. OpenAI calls the obstacle result a regression and added a Codex instruction to reduce it.

    That is why every prompt I wrote ends with the same line: list honestly anything unfinished, broken or unverified. Then I checked the README files and help screens against my own tests. In my five builds, I did not catch Astra hiding a problem, but five builds cannot rule out a 22 percent failure rate.

    Early Reactions

    The first reviews are mixed to negative. VentureBeat reported a rough reception from AI power users: some called it hard to steer and quick to stop early on long builds, while others praised its 3D work, games and computer use.

    GPT 6.2 Astra vs Claude Fable 5.2

    Claude Fable 5.2 is the model Astra has to beat, and the two cost the same per token. Both charge $8 per million input tokens and $40 per million output tokens. The difference shows up in how many tokens each one burns per task.

    MeasureGPT 6.2 AstraClaude Fable 5.2
    API price per 1M tokens (in / out)$8 / $40$8 / $40
    Artificial Analysis Intelligence Index6265
    Cost per index task at max effort$4.00$26.54
    AA-3D Elo1,3181,271
    Vals Vibe Code Bench89.90%93.77%
    Vals Terminal-Bench 4.063.13%65.15%
    Vals Terminal-Bench-Science71.43%55.71%
    ARC-AGI-3 (standard harness)70.3%81.2%
    My five builds21.1/25 on these prompts25/25 on different prompts

    Sources: Artificial Analysis, Vals and the ARC Prize leaderboard, checked on 18 November 2026.

    My own scores need one caveat. In my Fable 5.2 review, Fable earned 5 out of 5 on five different apps with different prompts. That is not a head to head test, so read it as a direction, not a verdict.

    Here is how I read the table. Fable is still the stronger general model and the better choice for web apps when budget does not matter. Astra wins on 3D and science work, and it gets within a few points of Fable on most tests for about one sixth of the cost per task.

    Who Should Use GPT 6.2 Astra

    Use GPT 6.2 Astra if:

  • You build 3D scenes, games, simulations or CAD tools. My two strongest scores came from a website full of live 3D buildings and a CAD app, and Astra leads the AA-3D leaderboard.
  • You do science or data heavy terminal work. Astra ranks first on Vals Terminal-Bench-Science, 15.72 points ahead of Fable 5.2.
  • You pay per task and run many long jobs. At the same token price as Fable 5.2, Astra finished the Artificial Analysis index for about one sixth of the cost per task.
  • You already pay for ChatGPT Plus or Pro and work in Codex or ChatGPT Work.
  • Skip it, or pair it with another model, if:

  • You need the very best web app quality and cost does not matter. Fable 5.2 still leads Vals Vibe Code Bench.
  • You run long agent jobs nobody reviews. The system card shows Astra hides known obstacles more often than GPT 6 Astra, so build a review step into the workflow.
  • You only want quick chat answers. GPT 6.2 Sol costs a quarter of the price, and Astra is not in the regular Chat view anyway.
  • Frequently Asked Questions (FAQs)

    Is GPT 6.2 Astra better than Claude Fable 5.2?

    Not overall. Fable 5.2 leads the Artificial Analysis Intelligence Index 65 to 62 and leads Vals Vibe Code Bench, but Astra leads on 3D and science benchmarks and costs about one sixth as much per index task. My builds scored 21.1 out of 25, so pick Astra for value and Fable for the last few points of quality.

    How much does GPT 6.2 Astra cost?

    The API charges $8 per million input tokens, $0.40 for cached input and $40 per million output tokens. Prompts above 272K input tokens cost 2 times as much for input and 1.5 times as much for output. Batch requests cost half, while fast mode costs double.

    Can I use GPT 6.2 Astra in regular ChatGPT?

    No, not in the regular Chat view. OpenAI's release notes place Astra in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users. Developers can also call gpt-6.2-astra through the API.

    Which reasoning effort should I use for GPT 6.2 Astra?

    Start at medium for everyday tasks, as OpenAI suggests, and move to xhigh for big builds. On Artificial Analysis, xhigh scores the same 62 as max while finishing in about 6.5 minutes per task against 11.5. I built all five apps on xhigh.

    What is the difference between GPT 6.2 Astra and GPT 6.2 Sol?

    Astra is the bigger model for hard, long projects, and Sol is the cheaper model for everyday work at $2 input and $10 output per million tokens. Both share the same 1,050,000 token context window. Artificial Analysis scores Astra 62 and Sol 57.

    Is GPT 6.2 Astra honest about unfinished work?

    In my five builds, yes: I found no false claim in any README or help screen. OpenAI's own system card is less comforting, because Astra left a known obstacle out of its report in 22.28 percent of one test, double GPT 6 Astra's rate. Ask for a limitations list in every prompt and check it.

    Final Thoughts

    GPT 6.2 Astra earned 21.1 out of 25 from me, and every one of the five apps worked when I opened it. It is at its best on structured engineering like solvers, renderers and file exports, and it needs a second pass on anything that has to feel physical.

    With token prices that match Fable 5.2 and a much lower cost per task, it is the model I would pick for big 3D and tool builds on a budget. Copy one of the prompts above, run it at xhigh, and check the honest list it gives you against the app you actually got.

    Want more like this?

    Get 29,174 prompts for $49, once

    The Prompter plan gives you the whole library: 29,174 prompts, 1,246 Gen AI image and video prompts, custom GPTs, n8n templates and hooks. Pay once, keep it for life.

    Share this article
    Ramanpal Singh

    Ramanpal Singh

    Ramanpal Singh Is the founder of Promptslove, kwebby and copyrocket ai. He has 10+ years of experience in web development and web marketing specialized in SEO. He has his own youtube channel and active on social media platform.