GPT 6.2 Sol costs a quarter of Astra's price per token, and OpenAI says many of its own staff use it as their default model.
I wanted to know if that cheaper model can still ship real apps, so I gave it five visual builds in the ChatGPT Desktop app: a toy car racer, a garden simulator, a ryokan website, a 3D gallery builder and a YouTube thumbnail studio.
This time Sol also had to make its own images, use real Unsplash photos and run AI features through Sign in with ChatGPT.
I tested every app, checked every image and every claim in its notes, and scored each build out of 5. Sol finished with 20.1 out of 25, and in this review you get every prompt I used, every score and every problem I found.
Key Takeaways
What Is GPT 6.2 Sol?
GPT 6.2 Sol is OpenAI's everyday model in the GPT 6.2 family. OpenAI launched it on 17 November 2026 together with GPT 6.2 Astra, the bigger model for long, hard projects.
OpenAI calls Sol smarter and more efficient than GPT 6.1 Sol at the same price. In Codex, OpenAI's own guide suggests Sol for reviewing a pull request or revising code, and Astra for tracing a bug across services.
GPT 6.2 Sol Specs at a Glance
| Spec | GPT 6.2 Sol | GPT 6.2 Astra |
|---|---|---|
| API model ID | gpt-6.2-sol | gpt-6.2-astra |
| Context window | 1,050,000 tokens | 1,050,000 tokens |
| Max input / output | 922K / 128K | 922K / 128K |
| Knowledge cutoff | 1 June 2026 | 18 May 2026 |
| Input and output | Text and image in, text out | Text and image in, text out |
| Price per 1M tokens | $2 in, $0.10 cached, $10 out | $8 in, $0.40 cached, $40 out |
| Above 272K input tokens | Input and cache 2x, output 1.5x | Input and cache 2x, output 1.5x |
Sol keeps the same $2 and $10 token prices as GPT 6.1 Sol, which makes it a quarter of Astra's price per token. Batch requests cost half and fast mode costs double.
Where You Can Use It
In ChatGPT, Sol lives in Work and Codex. OpenAI's help page lists Plus, Pro, Business, Enterprise and Edu, and says to open Work, because Sol is not in the regular Chat view.
One setting catches people out. New Work chats on consumer plans start Sol at Light reasoning effort, so you have to raise it yourself for real build work.
In Codex, Sol stretches your plan further. OpenAI's Codex pricing page estimates 17 to 180 local Sol messages per five hours on Plus, against 6 to 50 for Astra. The $200 Pro plan also gets Ultrafast mode with Sol.
How I Tested GPT 6.2 Sol
I wrote one long prompt for each app, in the same style as my Astra test. Every prompt names the stack, lists every system, ends with a VERIFY checklist, and asks the model to finish everything and then list honestly what it did not finish, what does not work and what it did not check.
This set adds two things Astra did not face. Every prompt includes an asset list for the built in image generator, so Sol had to make its own textures, art and illustrations. Three apps also had to work with Unsplash photography, and two had to run their AI features through Sign in with ChatGPT instead of an API key.
I built all five apps in the Codex app with GPT 6.2 Sol on Ultra, the top setting. Ultra uses the deepest reasoning the model supports and can hand parts of a big task to subagents. My Astra builds ran on xhigh as a single agent, so keep that difference in mind when you compare the two reviews.
Then I tested each app in five ways:
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 with ChatGPT or add Unsplash keys, so I tested the AI and photo search features by reading the code and checking the no key behavior.
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 Sol Scoreboard
| # | App | What it is | Uses | Score | My verdict |
|---|---|---|---|---|---|
| 1 | Tiny Turbo | Toy car racing game | Image generation, procedural 3D | 3.6/5 | Solid engineering, thin racing |
| 2 | Verdant | Garden growth simulator | Image generation | 4.1/5 | Real ecology, held back by a plant cap |
| 3 | Kumoi | Six page ryokan website | Unsplash, image generation | 4.1/5 | Stunning seasons, one homepage bug |
| 4 | Exhibit | 3D gallery builder | Sign in with ChatGPT, Unsplash API | 4.2/5 | Passed every test, lighting is flat |
| 5 | Clickworthy | YouTube thumbnail studio | Sign in with ChatGPT, Unsplash API | 4.1/5 | Useful tool, clipped AI panel |
| Total | 20.1/25 | Reliable builder, rough finish |
All five apps loaded with zero console errors in my test browser.
Build 1: Tiny Turbo, the Toy Car Racer (3.6/5)
Tiny Turbo asks Sol for an arcade kart racer at toy scale: small cars racing across a kitchen counter, a bedroom floor, a garden at dusk and a wet bathroom. I wanted to see if Sol can make a game feel big when the cars are tiny, and whether its generated art holds up inside a 3D world.
The Prompt I Used
I ran this prompt in the Codex app with GPT 6.2 Sol on Ultra.
Build "Tiny Turbo", a 3D toy-car racing game. Small toy cars race through a giant house: across the
kitchen counter, around a child's bedroom, through the garden at dusk, and over a wet bathroom floor.
Think arcade kart racing at toy scale: drifting, boosts, items, AI rivals, a grand prix, and
2-player split-screen.
Deliver a small web project as a zip:
index.html · game.js (ES modules are fine, split into files if you like) · assets/ (models,
textures, ui) · README.md
Modern three.js via importmap, pin this exact setup:
<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>
SRGBColorSpace, ACESFilmicToneMapping, no deprecated APIs. Addons allowed: GLTFLoader,
EffectComposer, RenderPass, SSAOPass, BokehPass, UnrealBloomPass, OutputPass.
═══════════ 3D ASSETS: TWO PATHS, BOTH MUST WORK ═══════════
PATH A: ready-made CC0 models (use if I add them):
Kenney's "Toy Car Kit" (kenney.nl/assets/toy-car-kit, CC0, about 100 files: toy cars plus four
types of track pieces). Load models from assets/models/ using a manifest file
(assets/models/manifest.json) that lists car files and track-piece files. Use the glTF/GLB versions
of the models. Write the manifest format and a README section telling me exactly which files to copy
where.
PATH B: procedural (always present, used for anything missing):
- Toy cars built from primitives: rounded plastic body, chunky wheels with hubs, a spoiler, a
windscreen, headlights. Distinct silhouettes per car class.
- All household scenery built from primitives plus the generated textures below: cereal boxes,
books, toy blocks, fruit, mugs, a sink, a tap, a towel, a bath, a rubber duck, garden hose,
grass blades, flower pots, plant leaves.
The game must run fully on PATH B alone. If GLB loading fails, log it and fall back without crashing.
═══════════ IMAGE ASSETS: GENERATE THESE WITH YOUR IMAGE GENERATOR ═══════════
STYLE LINE (use in every prompt): "Bright, playful toy-commercial look, soft studio lighting, clean
shapes, saturated colours, no real brand names or logos, no text unless specified."
Save each to the exact path. If you can't write generated images into the project, show each one with
its filename so I can save it. Every image needs a code fallback (flat colour, gradient or canvas
pattern). Never use real brands, logos or real people's likenesses.
assets/textures/cereal-box-1.png … cereal-box-3.png (1024×1536, fictional cereal brands, front art)
assets/textures/book-cover-1.png … book-cover-6.png (768×1024, fictional children's book covers)
assets/textures/playmat.png (2048×2048, top-down kids' play-mat town with roads, the bedroom track runs on it)
assets/textures/marble-counter.jpg (1024×1024, seamless white marble)
assets/textures/wood-floor.jpg (1024×1024, seamless oak floorboards)
assets/textures/rug.jpg (1024×1024, seamless patterned rug)
assets/textures/bath-tiles.jpg (1024×1024, seamless wet bathroom tiles)
assets/textures/garden-soil.jpg (1024×1024, seamless soil and pebbles)
assets/textures/wallpaper.jpg (1024×1024, seamless kids' bedroom wallpaper)
assets/decals/livery-1.png … livery-8.png (512×512, transparent, racing stripes, numbers, flames, stars)
assets/ui/logo.png (1600×600, transparent, "TINY TURBO" wordmark)
assets/ui/driver-1.png … driver-8.png (512×512, original cute toy-figure drivers, NOT existing characters)
assets/ui/item-*.png (256×256, transparent, one per item listed below)
assets/ui/track-kitchen.png, track-bedroom.png, track-garden.png, track-bathroom.png (1280×720 previews)
assets/ui/title-keyart.png (1920×1080, cars racing past a giant cereal box)
assets/ui/trophy-gold.png, trophy-silver.png, trophy-bronze.png (512×512, transparent)
assets/sky/window-day.jpg, window-dusk.jpg (2048×1024, views out of a house window)
═══════════ THE CAR PHYSICS ═══════════
Fixed timestep (120Hz), interpolated rendering.
- Arcade raycast car: four suspension rays with spring and damping, so cars bounce over book edges
and settle after jumps.
- DRIFTING: hold the drift button through a turn to slide. Sparks change colour as the drift
lasts longer (blue → orange → purple); releasing gives a matching MINI-TURBO boost.
- SURFACES with different grip and sound: marble (slippery), wood (normal), rug (grippy, slower),
wet tiles (very slippery), grass and soil (bumpy, slower), play-mat (normal).
- Jumps with a little air control; landing boost if the car lands straight.
- FALLING OFF THE EDGE matters: driving off the kitchen counter shows the long drop to the floor,
then respawns the car on the track with a small time loss.
═══════════ THE FOUR TRACKS ═══════════
1. KITCHEN COUNTER: around cereal boxes and the fruit bowl, a jump over the sink, a cutting-board
ramp, a slippery marble section, a window behind showing the day sky
2. BEDROOM: racing on the printed play-mat roads, through a dark tunnel under the bed lit only by
headlights, around block towers, up a book ramp
3. GARDEN AT DUSK: between giant grass blades, over the hose, past a sprinkler that sprays across
the track on a timer, fireflies glowing, a dusk sky
4. BATHROOM: wet tiles everywhere, around the rubber duck, along the edge of the bath, a soap-bar
boost strip
Each track: a spline-defined racing line, checkpoints, boost pads, item boxes, lap and wrong-way
detection, and a minimap.
═══════════ ITEMS (toy-themed, no weapons) ═══════════
Bouncy ball (rolls ahead and bumps the car it hits) · Glue puddle (dropped behind, slows) ·
Magnet (pulls you toward the car ahead) · Rocket boost · Bubble shield (blocks one item) ·
Wind-up spring (jump over hazards). Item boxes respawn after pickup; positions further back get
better items.
═══════════ AI RIVALS, MODES ═══════════
7 AI cars that follow the racing line with personality (aggressive, cautious, item-happy), drift
through corners, use items, and rubber-band mildly. Modes: single race, 4-track GRAND PRIX with
points and a podium ceremony with the trophy art, TIME TRIAL with a ghost of your best lap, and
2-PLAYER SPLIT-SCREEN (keyboard + gamepad, or two gamepads).
═══════════ THE TOY LOOK (this sells the whole game) ═══════════
- Low camera close to the cars, so the household objects tower over them
- TILT-SHIFT depth of field (BokehPass) for a miniature-photography feel
- Glossy plastic car materials with an environment map, soft shadows, SSAO in corners
- Light bloom on headlights and boost flames only
- Small details: dust motes in sunlight, droplets on the bathroom tiles, crumbs on the counter
═══════════ UI & AUDIO ═══════════
Animated title screen with the key art and logo, driver select with the portraits, car select with
liveries, track select with previews, settings (graphics quality Low → Ultra, controls, volumes),
pause, results and podium. HUD: position, lap, item slot, drift meter, minimap.
Web Audio, synthesized: a whiny toy motor that pitches with speed, plastic clacks on bumps, tyre
squeaks when drifting, a boost whoosh, item sounds, a cheerful music loop.
═══════════ VERIFY ═══════════
□ The game runs fully with no files in assets/models (procedural path)
□ It also runs with the Kenney models added, per the README
□ Drifting builds three boost levels and the boost matches the spark colour
□ Each surface has noticeably different grip
□ Falling off the counter respawns correctly
□ AI cars finish races on all four tracks
□ Split-screen runs at 60fps on a mid-range laptop
□ A missing image falls back without errors
Finish every part. When you're done, list honestly anything you didn't finish, anything that
doesn't work as specified, and anything you didn't check. Deliver everything as a zip.What Sol Built
Sol delivered a static three.js game of about 4,100 lines, split into clear modules for the menus, the simulation, the world, the graphics, the cars and the audio. It uses the exact importmap from the prompt, and every postprocessing pass I allowed.
The menus are the best looking part of the game. The title screen, the garage with a live 3D car preview and the illustrated track cards look like a finished console game.
What Worked
What Did Not Work
One brand note. A generated cereal box called "Honey Hoops" with a bee mascot sits close to real honey cereal brands, and the title art pairs a cartoon tiger with a bowl of cereal flakes. Neither copies a real mascot, but I would swap the bee box before using this art in a thumbnail.
Did Sol Tell the Truth?
The README holds up. Its claims about 49 generated images, running with no models, per model fallbacks and the graphics tiers were all true. It also says plainly that the 60 fps split screen check ran on a Mac Studio, not a mid range laptop, and that no physical controllers were tested.
It leaves a few gaps unmentioned: no collision, the AI banners on your HUD, the soap bar boost strip that is just a pink pad, and a bathroom track that circles the bath instead of running along its edge.
My Score: 3.6 out of 5
| Rubric item | Score |
|---|---|
| Driving feel (drift, surfaces, jumps) | 3.5 |
| The toy scale look | 3.0 |
| Tracks and generated assets | 3.5 |
| AI rivals and modes (including split screen) | 3.5 |
| Reliability (runs with or without models) | 4.5 |
| Overall | 3.6 |
Tiny Turbo is well engineered and almost impossible to crash, but it plays like a solid prototype. Add collision, longer tracks and denser rooms, and it becomes a real game.
Build 2: Verdant, the Garden Growth Simulator (4.1/5)
Verdant is my favorite kind of test, because nothing can be faked. I asked for a 3D garden where plants compete for sunlight and water, bees pollinate flowers, seeds spread, and the garden changes over 20 years from flowers to trees to ferns. The rule that matters most: nobody scripts that change.
The Prompt I Used
I ran this prompt in Codex on Ultra. "The importmap above" refers to the three.js importmap in the Tiny Turbo prompt.
Build "Verdant", a 3D garden simulator. Plant seeds, then watch the garden grow over days, seasons
and years. Plants compete for sunlight and water, bees pollinate flowers, seeds spread, and the
garden slowly changes: fast-growing flowers come first, then shrubs, then trees whose shade lets
ferns take over underneath. Nobody scripts that change; it comes out of the rules.
Deliver: verdant.html with assets/ beside it, as a zip. Modern three.js via the importmap above
(three@0.170.0). Write the simulation yourself.
═══════════ IMAGE ASSETS: GENERATE THESE WITH YOUR IMAGE GENERATOR ═══════════
STYLE LINE: "Naturalistic botanical style, soft daylight, fine detail, no text unless specified."
Save to the exact paths, or show each with its filename if you can't write images into the project.
Every image needs a code fallback.
assets/textures/bark-oak.jpg, bark-birch.jpg, bark-apple.jpg (1024×1024, seamless)
assets/textures/leaves-oak.png, leaves-birch.png, leaves-apple.png, leaves-fern.png,
leaves-ivy.png, leaves-lavender.png (1024×1024, transparent leaf cluster atlases)
assets/textures/petals-sunflower.png, petals-poppy.png, petals-lavender.png, blossom-apple.png
(512×512, transparent)
assets/textures/grass-blades.png (1024×1024, transparent)
assets/textures/soil.jpg, mulch.jpg, stone-path.jpg, fence-wood.jpg (1024×1024, seamless)
assets/ui/seed-<species>.png (768×1024, one vintage illustrated seed packet per species)
assets/ui/icon-water.png, icon-prune.png, icon-seed.png, icon-fence.png (256×256, transparent)
assets/ui/title.png (1920×1080, a lush garden at golden hour)
Optional: in the plant guide panel, show a real reference photo of each species from Unsplash
(images.unsplash.com URLs with ?w=800&q=80&auto=format), credit each photographer with a link to
their Unsplash profile, and add an onerror fallback. Don't use source.unsplash.com; it no longer works.
═══════════ THE PLANTS ═══════════
Species, each with traits (growth speed, maximum height, shade tolerance, water need, lifespan,
seed spread):
Oak · Birch · Apple tree · Sunflower · Lavender · Poppy · Fern · Grass · Clover · Ivy
- Trees and shrubs GROW with a branching algorithm (L-system or space colonization): new branches
and leaves each season, trunks thickening year by year.
- PHOTOTROPISM: plants bend and grow toward the light.
- Flowers bloom in their season and need pollination to set seed (and the apple tree to fruit).
- Plants die when starved of light or water, or at the end of their lifespan, and decompose into
soil nutrients.
- Render efficiently: instanced leaves and grass, merged branch geometry per plant, LOD for distance.
═══════════ THE ENVIRONMENT ═══════════
- SUN: position from time of day and season. Each plant's LIGHT is measured from shadows cast by
everything taller around it; tall plants really do shade small ones.
- WATER: a soil-moisture grid filled by rain, drained by evaporation (faster in sun) and by roots.
- NUTRIENTS: a soil grid fed by decomposing plants and fallen leaves.
- SEASONS: spring sprouting and blossom, full summer canopy, autumn leaf colour and falling leaves
that pile up, winter dormancy with snow on branches and ground.
- WEATHER: sunny, cloudy, rain showers, storms (wind sways and can break branches), droughts.
- BEES fly between flowers, carrying pollen. More flowers draw more bees.
- SEEDS spread by wind (birch, dandelion-like), by falling (apple), and by birds; they sprout only
where light, water and space allow.
═══════════ WHAT SHOULD EMERGE (not be scripted) ═══════════
Over 20+ simulated years: fast flowers and grass dominate early → shrubs establish → trees rise and
shade the ground → sun-lovers (sunflower, poppy, lavender) retreat to open patches → ferns and ivy
thrive under the canopy. This is ecological succession; it must come from light, water and growth
rules alone.
═══════════ INTERACTION ═══════════
Plant from the seed-packet cards, water, prune, remove, build a fence or wall (it casts shade),
set climate (rainfall, temperature, season length), and control time: pause, real-time, 1 day/sec,
1 season/sec, 1 year/sec. Orbit, zoom, and a low "walk the garden" camera. A time-lapse recorder that
exports a WebM of the garden growing.
═══════════ DATA ═══════════
Charts in hand-written SVG: population of each species over time, total leaf area, a biodiversity
score. Overlays on the ground: light level, soil moisture, nutrients. Click a plant to see its age,
height, light, water, health and parents.
═══════════ VERIFY ═══════════
□ A sunflower planted under an oak grows slower and leans out toward the light
□ Ferns do better in shade than in full sun
□ Unpollinated flowers set no seed; flowers bees visit do
□ Over 20 years, the succession pattern appears without being scripted
□ Seasons visibly change leaves, flowers and snow
□ Drought kills water-hungry plants first
□ The same seed produces the same garden
□ 60fps with 300+ plants
Finish every part. When you're done, list honestly anything you didn't finish, anything that
doesn't work as specified, and anything you didn't check. Deliver everything as a zip.What Sol Built
Sol delivered one HTML file of about 2.4 MB with the assets folder beside it. It packed three.js and smaller copies of every texture into the file, so the garden also works when you open it straight from your disk.
The generated art is lovely. The seed packets look like vintage botanical plates, the bark and soil textures tile without seams, and the golden hour title art shows every species in the simulation.
What Worked
The ecology code split cleanly out of the HTML file, so I ran it on its own and measured every VERIFY item.
What Did Not Work
Did Sol Tell the Truth?
Sol's progress notes in my project folder hold up. They say the optional Unsplash photos were skipped and that performance was only measured on my Mac. They also report a working WebM recording and about 60 fps with up to 600 plants on my Mac, which I could not check in software rendering.
The notes do not mention the 600 plant cap or the forced starter garden, the two limits that matter most for the 20 year story.
My Score: 4.1 out of 5
| Rubric item | Score |
|---|---|
| Growth and branching quality | 3.5 |
| Light competition and seasons | 4.5 |
| Emergent succession | 4.0 |
| Generated textures and look | 4.5 |
| Data views and time lapse | 4.0 |
| Overall | 4.1 |
Verdant is the build where Sol did the hard science right. Lift the plant cap and add a bare soil option, and the 20 year succession clip films itself.
Build 3: Kumoi, the Mountain Ryokan Website (4.1/5)
Kumoi is the image generator test. I asked for a six page website for a fictional ryokan, a traditional Japanese inn, built around one scroll moment: the same courtyard shown in spring, summer, autumn and winter. Holding one composition across four generated images is something image models usually get wrong.
The Prompt I Used
I ran this prompt in Codex on Ultra. "The importmap above" refers to the three.js importmap in the Tiny Turbo prompt.
Build the website for "Kumoi", a fictional ryokan (traditional Japanese inn) high in the mountains, with
hot-spring baths, seasonal kaiseki dinners, and rooms looking over a cedar forest. A complete
MULTI-PAGE site: 6 interlinked pages, one design system, one nav, page transitions. Photo-led,
IMMERSIVE, ANIMATION-HEAVY, and calm. Kumoi is fictional; don't imitate any real inn.
Deliver a zip: shared.css · shared.js · 6 HTML pages · js/ per page · assets/ · README.md
STACK: GSAP 3.12 + ScrollTrigger, Lenis smooth scroll, Lucide icons, Google Fonts, and three.js via
the importmap above for the WebGL effects. No frameworks.
═══════════ IMAGES: TWO SOURCES ═══════════
1. UNSPLASH for real-world photography (mountains, cedar forest, mist, hot-spring water, tatami
rooms, tea, seasonal food, autumn leaves, snow): browse unsplash.com, choose specific photos, and
use their images.unsplash.com URLs with size parameters (e.g. ?w=2000&q=80&auto=format). Use srcset
for responsive sizes. Credit each photographer on a credits page and in the footer of each page,
with a link to their Unsplash profile. Add an onerror fallback to every image. Don't use
source.unsplash.com; it no longer works.
2. YOUR IMAGE GENERATOR for anything specific to Kumoi that stock photos can't show.
STYLE LINE: "Photographic, soft natural light, quiet and serene, muted natural palette, no text, no
people's faces."
Save to the exact paths, or show each with its filename if you can't write images into the project.
Every image needs a code fallback.
assets/gen/courtyard-spring.jpg, courtyard-summer.jpg, courtyard-autumn.jpg, courtyard-winter.jpg
(2400×1350): THE SAME courtyard from THE SAME camera position: a wooden engawa veranda in the
foreground, a stone lantern, a small pond, a maple tree, a mountain behind. Only the season
changes (cherry blossom / deep green with fireflies at dusk / red maple / snow). Generate
spring first, then describe it exactly in the other three prompts to keep the composition.
assets/gen/branch-sakura.png, branch-maple.png, branch-pine-snow.png (1600×900, transparent
foreground branches used as parallax layers over the courtyard)
assets/gen/exterior.jpg (2400×1350, the ryokan's wooden building at dusk with warm paper lanterns)
assets/gen/room-mountain.jpg, room-garden.jpg, room-suite.jpg (1800×1200, room interiors)
assets/gen/onsen-outdoor.jpg, onsen-indoor.jpg (1800×1200, empty baths with steam)
assets/gen/kaiseki-1.jpg … kaiseki-8.jpg (1200×1200, one course each, overhead)
assets/gen/map.png (2400×1600, an ink-wash illustrated map: the station, the mountain road,
the ryokan, the forest trails, the waterfall)
assets/gen/stamp-*.png (512×512, transparent, red hanko-style seal stamps)
═══════════ DESIGN DIRECTION: "quiet luxury, washi and ink" ═══════════
Light-first, with a dark "night" theme. Palette: washi off-white, sumi ink black, cedar brown,
moss green, and a single vermilion accent (used sparingly, like a seal stamp). A refined serif for
display, a light sans for body, generous margins, vertical rhythm, lots of empty space.
CURSOR: an ink-brush dot that leaves a short fading sumi-ink trail. On hover over links it swells
like a brush pressed down. Hidden on touch devices.
PAGE TRANSITIONS: shoji screens, two paper panels slide closed from the sides, then open on the next page.
HEADINGS: revealed with an ink brush-stroke mask (SVG) as they scroll into view.
═══════════ PAGE 1: index.html ═══════════
- HERO: the exterior at dusk, full-bleed, with a WebGL layer of drifting mist and a few lanterns
flickering. The name appears with a brush-stroke reveal.
- THE SIGNATURE: "FOUR SEASONS AT KUMOI" (pinned, ~500vh): the courtyard image crossfades from
spring to summer to autumn to winter as you scroll. Parallax foreground branches change with the
season. Season particles fall across the scene: cherry petals, then fireflies, then maple leaves,
then snow. A short line of text for each season, and a small vertical seasonal calendar marker.
- Then: an introduction, three room previews, the hot springs, the kaiseki dinner, a guest quote,
how to get there with the illustrated map, and a reservation call to action. 11+ sections.
═══════════ PAGE 2: rooms.html ═══════════
Each room type with a gallery, layout, view, capacity and rate; a DAY/NIGHT toggle that dims the
room photo and lights paper lanterns over it; a comparison table.
═══════════ PAGE 3: onsen.html ═══════════
The hot springs: a WebGL STEAM effect rising over the bath photos, water temperatures, mineral
content, bathing etiquette explained simply with small illustrations, and private-bath booking times.
═══════════ PAGE 4: cuisine.html ═══════════
The kaiseki dinner served course by course as you scroll (each course slides in like a dish being
set down), a note on each course's seasonal ingredients, breakfast, dietary requests.
═══════════ PAGE 5: seasons.html ═══════════
A year at Kumoi: an interactive circular calendar of what's in season (flowers, foods, festivals,
hiking conditions); pick a month and the page's colours, particles and photos shift to match.
═══════════ PAGE 6: reserve.html ═══════════
A booking flow: dates (calendar with availability), room, guests, dinner preferences, arrival time,
summary. On confirmation, a red seal stamp presses onto the booking card. Validated and accessible.
SHARED: Lenis + a thin progress line, the ink cursor, theme toggle (light/night) persisted in
localStorage, scroll reveals, gentle hover states, the shoji transition, responsive (the seasons
sequence still works on phones), reduced-motion respected (crossfades become still images),
accessible, 60fps, pixel ratio capped at 2.
Finish every page. When you're done, list honestly anything you didn't finish, anything that doesn't
work as specified, and anything you didn't check, including which generated images didn't match the
brief. Deliver everything as a zip.What Sol Built
Sol built six interlinked pages plus a credits page, with one shared design system in washi off white, sumi ink black and a single vermilion accent. It uses GSAP with ScrollTrigger, Lenis, Lucide icons, Google Fonts and a small three.js shader, with no framework.
GENERATION.md that records the prompt behind every generated imageWhat Worked
The four courtyards are the best result in this whole review. When I laid summer and autumn over spring, the stone lantern, the veranda post, the pond, the maple trunk and the mountain lined up to the pixel, with zero shift. Winter drifts a little more, because snow reshapes the pond edge and the shrubs.
The pinned "Four seasons" sequence uses them well. As you scroll about five screens, the courtyard crossfades through the year, a seasonal branch slides across the foreground, and the particles change from cherry petals to fireflies to maple leaves to snow. A vertical calendar tracks the season, and clicking it jumps to that season.
The rest of the site works as asked:
The other generated images are strong too. The eight kaiseki courses share one table, one light and one camera angle, so they read like a single photo shoot.
What Did Not Work
Did Sol Tell the Truth?
Mostly. The README says the four courtyards came from the same spring reference and that small differences remain, which matches my overlay test exactly. It also documents every image prompt and the replaced sakura cutout.
It says the site was checked in headless Chrome at desktop and mobile sizes, yet those checks missed the homepage image bug, which shows at both sizes. It also skips the red spring maple and the single stamp, which the prompt asked it to report.
My Score: 4.1 out of 5
| Rubric item | Score |
|---|---|
| The four seasons sequence (and courtyard consistency) | 4.5 |
| Photo selection and generated images | 4.0 |
| Design quality | 3.5 |
| Immersive details (steam, ink, shoji, stamp) | 4.0 |
| Multi page consistency | 4.5 |
| Overall | 4.1 |
Kumoi proves Sol plus the Codex image tool can hold a scene steady across four seasons. Fix one CSS rule on the homepage and this site is ready to show a client.
Build 4: Exhibit, the 3D Virtual Gallery Builder (4.2/5)
Exhibit turns a set of photos into an exhibition you can walk through. You search Unsplash or drop in your own images, the AI groups them into rooms and writes the wall labels, and you visit the result in first person or take a guided tour. Then you export the whole show as a static website.
The Prompt I Used
I ran this prompt in Codex on Ultra.
Build "Exhibit", a local app that turns a set of photos into a walkable 3D gallery. Search Unsplash or
drop in your own images; the AI groups them into rooms, orders them, names the exhibition and writes
the wall labels; then you walk through it in first person or take a guided tour. Export the finished
exhibition as a static website.
Deliver a zip: a local Node app.
server/ (Node 20+, Express): holds the Unsplash key and the ChatGPT session
web/ (React + Vite): the editor and the 3D gallery (three.js 0.170.0)
README.md: setup in a few steps; `npm install` then `npm start`
═══════════ AI: SIGN IN WITH CHATGPT (no API keys) ═══════════
Users click "Continue with ChatGPT" and the AI runs on their ChatGPT plan.
- Use OpenAI's Sign in with ChatGPT devkit: @siwc/local on the server (createChatGPT, signIn,
getSession, listModels, streamResponse) and @siwc/react in the web app (the sign-in button, the
connection card, the Manage usage button). It's a preview: read the devkit README
(github.com/openai/sign-in-with-chatgpt-devkit) and developers.openai.com/siwc/quickstart first,
and follow them where they differ from this prompt.
- Signing in and allowing plan usage are separate. Check that plan usage is on (session.sharing)
before every AI call; if it isn't, explain how to turn it on.
- Choose the model from listModels(): prefer a gpt-6.2-sol slug, otherwise the best available, and
let the user switch.
- UI: "Continue with ChatGPT" before sign-in; the account and "Connected" after; "Using ChatGPT
plan" next to the model picker; a "Manage usage" action (chatgpt.com/settings/usage), which is
the main action in any usage-limit error.
- Treat a request as successful only after the completed response arrives.
- Image generation isn't available through the plan in this preview. Don't build features that
need it. Sending photos to the model as input is how curation works; check the preview-
limitations page to confirm it's supported, and fall back to captions plus Unsplash descriptions
if not.
- Everything except the AI features works without signing in.
═══════════ UNSPLASH (live search) ═══════════
- Unsplash API with the user's access key (UNSPLASH_ACCESS_KEY in .env, kept on the server).
Search photos, show results in a grid, add them to the exhibition.
- Rules from Unsplash's API guidelines: hotlink the image URLs the API returns; show "Photo by
[name] on Unsplash" with links to the photographer and Unsplash (with utm_source=exhibit and
utm_medium=referral); call the photo's download_location endpoint when a photo is added to an
exhibition.
- Demo keys allow 50 requests an hour: cache searches and show remaining quota.
- Local images: drag and drop from disk, stored locally.
═══════════ BUILD-TIME IMAGE ASSETS: GENERATE WITH YOUR IMAGE GENERATOR ═══════════
STYLE LINE: "Clean architectural photography of an empty gallery, soft daylight, no text, no people."
Save to the exact paths, or show each with its filename. Every image needs a code fallback.
web/public/textures/concrete-floor.jpg, oak-floor.jpg, terrazzo-floor.jpg (1024×1024, seamless)
web/public/textures/plaster-wall.jpg, concrete-wall.jpg (1024×1024, seamless)
web/public/ui/onboarding-1.png … onboarding-3.png (1600×1000, illustrations explaining the 3 steps)
web/public/ui/empty-state.png (1200×800, an empty gallery waiting for art)
═══════════ THE AI CURATOR ═══════════
1. CURATE: send the chosen images (and their Unsplash descriptions) and get back JSON:
{ "title": "...", "intro": "a short exhibition introduction",
"rooms": [ { "name": "...", "theme": "...", "wall_colour": "#hex",
"works": [ { "image_id": "...", "label_title": "...",
"label_text": "40 to 80 words", "order": n } ] } ] }
Validate it: every image_id must exist, every chosen image placed exactly once, sensible text
lengths.
2. REWRITE: "make the labels more playful", "rename room 2", "write it for kids".
3. AUDIO-GUIDE SCRIPT: a short spoken script per room, shown as text for now.
═══════════ THE 3D GALLERY ═══════════
- Generate the building from the curation: a sequence of rooms joined by doorways, sized to fit
their works, with the chosen wall colours and floor textures.
- Hang each image in a FRAME sized to its aspect ratio, with a gallery spotlight on it and a small
wall label (title + text) beside it, readable when you walk close.
- Lighting: soft skylights, warm spotlights, gentle shadows, a subtle reflection on polished floors.
- Walk in first person (WASD + mouse, with collision against walls), or take a GUIDED TOUR, a
smooth camera path that stops at each work for a few seconds.
- Click a work to view it full-screen with the label and photo credit.
- An overhead floor-plan minimap showing where you are.
═══════════ EDITOR ═══════════
A 2D floor-plan editor beside the 3D view: drag works between walls and rooms, reorder, change wall
colours, add a room, edit labels. The 3D view updates live.
═══════════ EXPORT ═══════════
Export the exhibition as a static website folder (index.html + assets) that anyone can open or host:
the 3D walkthrough, the guided tour, all labels and all photo credits. Unsplash images stay
hotlinked with attribution, as the guidelines require.
═══════════ VERIFY ═══════════
□ Sign in with ChatGPT works end to end, shows "Using ChatGPT plan", and AI calls fail gracefully
when plan usage is off or the limit is reached
□ The app is fully usable without signing in (manual curation)
□ Every Unsplash photo shows correct attribution and triggers the download endpoint once when added
□ Every image ends up in the gallery exactly once, framed at the right aspect ratio
□ Walking never passes through walls; the guided tour visits every work
□ The exported site opens on its own and shows every credit
□ 60fps walking through a 40-work, 4-room exhibition
Finish every part. When you're done, list honestly anything you didn't finish, anything that doesn't
work as specified, and anything you didn't check. Deliver everything as a zip.What Sol Built
Exhibit is a local Express server plus a React and Vite studio of about 3,000 lines, with three.js for the gallery. It opens on a sample show called "The quiet form", built from six generated architecture photos.
What Worked
Exhibit passed every VERIFY item I could test, and most of them with numbers to spare.
The AI and Unsplash code is careful too. I could not sign in, so I fed the app a fake ChatGPT session through its own server hook.
It checked plan sharing before every call, defaulted to GPT 6.2 Sol with a model picker, showed "Using ChatGPT plan", and made "Manage usage" the main button on a usage limit error. It also rejected AI replies that invented photo IDs, placed a photo twice or wrote labels outside 40 to 80 words.
For Unsplash, every credit carries the right tracking tags, and the download event fires once per photo per exhibition, exactly as Unsplash's rules ask.
What Did Not Work
Did Sol Tell the Truth?
Every README claim I checked held up: the cached Unsplash searches, the once per exhibition download tracking, the caption fallback for image input, the tour order and the offline export. The README also explains the two small changes Sol made to the DevKit so the curator can send images.
One gap: my prompt asked Sol to confirm that the preview accepts images. The README links the limitations page but never states the answer.
My Score: 4.2 out of 5
| Rubric item | Score |
|---|---|
| 3D gallery look and lighting | 3.5 |
| Curation quality (rooms, order, labels) | 4.0 |
| Sign in with ChatGPT integration | 4.5 |
| Unsplash handling and attribution | 4.5 |
| Editor and export | 4.5 |
| Overall | 4.2 |
Exhibit is the most complete build in this set and the best Sign in with ChatGPT app I have tested. It needs real lights before it feels like a gallery and not a showroom.
Build 5: Clickworthy, the Thumbnail Studio (4.1/5)
Clickworthy is the build I can actually use for my own channel. I asked for a local thumbnail editor with layers, bold text, background removal and previews at the real sizes thumbnails appear in a feed, plus an AI that suggests concepts and critiques the design through Sign in with ChatGPT.
The Prompt I Used
I ran this prompt in Codex on Ultra.
Build "Clickworthy", a local app for designing YouTube thumbnails. A layer-based editor at 1280×720,
templates, cut-out subjects, bold text, and previews at the real sizes thumbnails appear in a feed.
An AI suggests concepts from a video title and critiques the current design.
Deliver a zip: a local Node app.
server/ (Node 20+, Express): holds the Unsplash key and the ChatGPT session
web/ (React + Vite): the editor
README.md: `npm install` then `npm start`
═══════════ AI: SIGN IN WITH CHATGPT (no API keys) ═══════════
Same rules as any Sign in with ChatGPT app:
- Use the devkit: @siwc/local on the server, @siwc/react for the sign-in button, connection card
and Manage usage button. It's a preview: read the devkit README
(github.com/openai/sign-in-with-chatgpt-devkit) and developers.openai.com/siwc/quickstart first,
and follow them where they differ from this prompt.
- Check plan usage is on (session.sharing) before every AI call; explain how to enable it if not.
- Model from listModels(): prefer a gpt-6.2-sol slug, otherwise the best available; user can switch.
- UI: "Continue with ChatGPT" → account + "Connected" → "Using ChatGPT plan" by the model picker →
"Manage usage" (chatgpt.com/settings/usage) as the main action on usage-limit errors.
- A request counts as successful only after the completed response arrives.
- No image generation through the plan in this preview; don't build features that need it.
Critique sends a downscaled PNG of the thumbnail as image input; confirm image input is supported
on the preview-limitations page, and if it isn't, send the layer list and text instead.
- The whole editor works without signing in.
═══════════ UNSPLASH (background photos) ═══════════
Unsplash API with UNSPLASH_ACCESS_KEY on the server. Search, add a photo as a background layer,
hotlink the API's image URLs, show photographer credit in the app, and call download_location when a
photo is added. Cache searches; show remaining quota for demo keys (50 requests/hour).
═══════════ BUILD-TIME IMAGE ASSETS: GENERATE WITH YOUR IMAGE GENERATOR ═══════════
STYLE LINE: "Bold, high-contrast YouTube thumbnail style, clean shapes, vivid colour, no text, no real
people, no logos."
Save to the exact paths, or show each with its filename. Every image needs a code fallback.
web/public/templates/bg-01.png … bg-12.png (1280×720, backgrounds: gradient glows, tech grids,
split versus layouts, spotlight, explosion of light, desk setup, abstract code)
web/public/stickers/arrow-*.png, circle-*.png, burst-*.png, check.png, cross.png, question.png,
warning.png (512×512, transparent)
web/public/ui/empty-state.png (1200×800)
═══════════ THE EDITOR ═══════════
- Canvas at 1280×720 (and a 1080×1920 Shorts-cover mode)
- LAYERS: image, text, shape, sticker, with reorder, lock, hide, opacity, blend modes, and a layer panel
- SUBJECT CUT-OUT: remove the background from a dropped photo in the browser with a background-
removal library such as @imgly/background-removal (runs locally; check its licence fits your use).
Add an outline/glow around the cut-out, the classic thumbnail look.
- TEXT: big bold fonts from a bundled Google Fonts list, thick outlines, drop shadows, gradient
fills, per-word colour, and slight rotation
- Arrows, circles, highlight boxes, emoji-free stickers from the generated set
- Snapping guides, safe-zone overlay (where YouTube's timestamp covers the bottom-right corner),
undo/redo, keyboard shortcuts
- 12 TEMPLATES built from the generated backgrounds: reaction, versus/comparison, tutorial, tier
list, before/after, "I tested X", benchmark results, news, list, story, warning, Shorts cover
═══════════ PREVIEW & CHECKS (the part that makes it useful) ═══════════
- FEED PREVIEW: the thumbnail shown at the sizes it really appears: home feed on desktop, search
results, the small suggested-video size (about 168px wide), and mobile, in a generic video-feed
mock-up with a fake title and channel line, in light and dark mode. Don't copy YouTube's logo or
branding.
- READABILITY CHECKS, computed: text contrast against what's behind it, text height at 168px width,
word count (warn above 5 words), whether the main subject takes up enough of the frame, and whether
anything important sits under the timestamp corner.
- A/B GRID: duplicate a design into variants and compare 2 to 4 side by side at feed size.
═══════════ THE AI ═══════════
1. CONCEPTS: enter a video title and a one-line summary; get 6 concepts as JSON, text overlay (4
words max), composition, emotion, background idea, colour pair, and Unsplash search terms. Clicking
a concept builds a draft from the closest template and runs the Unsplash search.
2. CRITIQUE: send the current thumbnail and get specific fixes ("the text is unreadable at small size;
raise it to 160px and add a 12px black outline"), each with a one-click "apply" where possible.
3. TITLES: 10 title options that match the thumbnail, flagged if they repeat the thumbnail's text.
Validate all AI JSON before using it.
═══════════ EXPORT ═══════════
PNG or JPG at 1280×720 under 2MB (YouTube's thumbnail limit), the 1080×1920 Shorts cover, and the
project file (re-openable). Projects saved locally.
═══════════ VERIFY ═══════════
□ Sign in with ChatGPT works end to end, and AI features fail gracefully without plan usage
□ The whole editor works without signing in
□ Background removal gives a clean cut-out that can be outlined
□ Feed previews show the right sizes in light and dark mode
□ Readability checks catch small text and text under the timestamp
□ Exported files are exactly 1280×720 and under 2MB
□ Every Unsplash background is credited and triggers its download endpoint once
Finish every part. When you're done, list honestly anything you didn't finish, anything that doesn't
work as specified, and anything you didn't check. Deliver everything as a zip.What Sol Built
Clickworthy is a local Express server plus a React and Vite editor of about 4,900 lines. It opens on an editable example and runs at 127.0.0.1 only.
It also includes two extras my prompt never asked for. An "Image lab" generates artwork through OpenRouter with your own key, and a YouTube inspiration panel pulls references from a library of 50 videos by 12 well known creators. Both are optional and switched off without keys, and the "Use layout" button builds an original draft instead of copying anyone's thumbnail.
What Worked
gpt-6.2-sol model with a picker, validates every JSON reply strictly, and falls back from a PNG critique to layer data if the model rejects images.The generated backgrounds and stickers match the brief: bold, vivid, high contrast and free of text and logos.
What Did Not Work
I could not test live sign in, AI generation or Unsplash search without accounts and keys, so those scores come from the code.
Did Sol Tell the Truth?
Every README claim I checked was true: the template, sticker and shape counts, the feed sizes, the export limits, the palette fallback and the critique fallback. The README also discloses that the app needs Node 22.12 instead of the Node 20 my prompt allowed, because the DevKit requires it.
There is no limitations list in the project files, so I cannot compare Sol's own honest list with what I found.
My Score: 4.1 out of 5
| Rubric item | Score |
|---|---|
| Editor quality (layers, text, cut outs) | 4.0 |
| Feed previews and readability checks | 4.5 |
| AI concepts and critique | 3.5 |
| Sign in with ChatGPT integration | 4.0 |
| Templates and export | 4.5 |
| Overall | 4.1 |
Clickworthy is a genuinely useful tool with the smartest readability checker I have seen in an AI build. Widen the AI sidebar and sharpen the cut outs, and I would use it every week.
What My Five Builds Tell You About GPT 6.2 Sol
The same patterns showed up across all five apps.
It Builds Things That Do Not Break
Not one app threw a page error in any of my runs. Tiny Turbo survived missing models, broken model files and seven blocked images, and every image in every app had a working fallback.
Sol also kept building ways to test its own work. Tiny Turbo and Verdant expose functions that let a script read the state and fast forward time, which is how I raced 140 AI cars and simulated 30 years of garden growth in minutes.
Its Image Work Is Excellent
Sol, working through the Codex image tool, produced every asset on all five lists. The Kumoi courtyards held one camera position across four seasons, the eight kaiseki courses look like one photo shoot, and the Verdant seed packets and textures look like a real botanical set.
The weak spot is how the art sits inside 3D scenes. Tiny Turbo's rooms look sparse next to its own track preview art, and Exhibit's gallery lighting is flat.
It Follows Platform Rules Closely
The two Sign in with ChatGPT apps check plan sharing before every AI call, prefer the Sol model, and put "Manage usage" first on limit errors, exactly as OpenAI's guidelines ask. Exhibit tracks each Unsplash download once and tags every credit link. Sol even edited the DevKit to send images and documented the change.
It Misses the Last Ten Percent
The misses are polish, not structure: no collision in the racer, one CSS rule that breaks the Kumoi homepage, a sidebar that clips Clickworthy's AI panel, and fake spotlights in Exhibit. Most of them look like quick fixes for a developer.
It Adds Extras You Did Not Ask For
Clickworthy gained an OpenRouter image lab and a YouTube reference library, and Exhibit gained a sample show and a help dialog. The extras are optional and isolated, but they are more code to review before you ship.
GPT 6.2 Sol Benchmarks: What the Independent Numbers Say
OpenAI's launch post says Sol lands within 0.5 points of Astra on FrontierCode 2.0 at about a fifth of the cost. That is OpenAI's own claim with no absolute score attached, so here is what the independent leaderboards show as of 19 November.
Artificial Analysis: Cheap Per Task, Flat at the Top
Artificial Analysis scores Sol 57 on its Intelligence Index, behind Astra at 62 and Claude Fable 5.2 at 65. The headline number is the cost: $1.01 per index task at max effort, against $4.00 for Astra and $26.54 for Fable.
| Effort | Index score | Minutes per task |
|---|---|---|
| Max | 57 | 8.7 |
| Xhigh | 56 | 5.4 |
| High | 55 | 4.7 |
| Medium | 53 | 3.3 |
| Low | 41 | 1.5 |
Source: Artificial Analysis model page for GPT 6.2 Sol, accessed 19 November 2026.
The effort curve is flat at the top. Going from high to max adds only 2 points, so extra thinking buys you very little with Sol. The big drop sits below medium.
Artificial Analysis also flagged a coding regression. Sol's Coding Agent Index fell 3 points below GPT 6.1 Sol, mostly from a 14 point drop on a repository question answering test.
3D, Coding and Puzzles
AA-3D test, Sol scores 1,259 Elo, behind Astra at 1,318 and Fable 5.2 at 1,271.Terminal-Bench 4.0, Sol scores 60.61 percent at $1.13, against 63.13 percent for Astra and 65.15 percent for Fable.Terminal-Bench-Science, Sol ranks fourth at 58.57 percent, just ahead of Fable 5.2 at 55.71 percent. On the broader Vals Science Index, Sol scores 57.76 percent, below GPT 6.1 Sol at 59.63 percent.ARC-AGI-2, down from 94.17 percent for GPT 6.1 Sol. On the ARC-AGI-3 standard harness it scores 54.93 percent, a small gain over GPT 6.1 Sol's 52.73 percent.What the System Card Says About Sol
OpenAI's GPT 6.2 system card shows a mixed safety picture for Sol. Improper actions in workplace simulations fell to 0.71 percent from 1.32 percent for GPT 6.1 Sol.
Confirmed misalignment flags in OpenAI's internal Codex traffic rose to 6.78 percent from 5.13 percent. It is a good reason to end every prompt the way mine do: list honestly anything unfinished, broken or unverified.
Early Reactions
Early reactions to Sol are calmer than the backlash Astra got. On YouTube, AICodeKing ran six Codex apps at high effort and gave Sol 34.1 points against 33.6 for Astra, at about a third of the cost. AI Coding Daily tested 35 coding prompts, saw no gain over GPT 6.1 Sol and stayed on the older model.
Simon Willison ran Sol at Ultra in the Codex CLI and found that neither Sol nor Astra matched Fable 5.2 on his test. On Hacker News, one developer called Sol "the workhorse" for its cost and accuracy, while another called it "a marginal step forward".
Apps That Run on Your ChatGPT Plan: What Sign in With ChatGPT Means
Two of my builds use OpenAI's Sign in with ChatGPT developer preview. Instead of pasting an API key, a user clicks "Continue with ChatGPT", and the app's AI features run on that person's ChatGPT plan.
Here is what the preview limitations page and the quickstart say right now:
tool_search are also off.One detail matters if you run an agency or sell software. The DevKit ships under a noncommercial license, so a commercial product needs a separate agreement with OpenAI.
GPT 6.2 Sol vs GPT 6.2 Astra vs Claude Fable 5.2
Sol costs a quarter of Astra's price per token and a quarter of Fable 5.2's. Here is how that trade looks on the independent leaderboards.
| Measure | GPT 6.2 Sol | GPT 6.2 Astra | Claude Fable 5.2 |
|---|---|---|---|
| API price per 1M tokens (in / out) | $2 / $10 | $8 / $40 | $8 / $40 |
| Artificial Analysis Intelligence Index | 57 | 62 | 65 |
| Cost per index task at max effort | $1.01 | $4.00 | $26.54 |
AA-3D Elo | 1,259 | 1,318 | 1,271 |
| Vals Vibe Code Bench | 87.62% | 89.90% | 93.77% |
Vals Terminal-Bench 4.0 | 60.61% | 63.13% | 65.15% |
Vals Terminal-Bench-Science | 58.57% | 71.43% | 55.71% |
| Vals Index | 66.06% | 67.66% | 71.31% |
ARC-AGI-3 (standard harness) | 54.93% | 70.31% | 81.2% |
| My five builds | 20.1/25 | 21.1/25 | 25/25 |
Sources: Artificial Analysis, Vals, the ARC Prize leaderboard and Anthropic's pricing page, checked on 19 November 2026.
My own scores need a caveat. My GPT 6.2 Astra review used different apps and different prompts, and Sol also had to make its own images. Read the last row as a direction, not a head to head result.
Here is how I read the table. Sol gives up about 2 points to Astra on most coding tests and a lot more on science and puzzles, but each task costs about a quarter as much. For everyday app building, that is a good trade.
Who Should Use GPT 6.2 Sol
Use GPT 6.2 Sol if:
Pick Astra or Fable 5.2 instead if:
AA-3D, and Sol's racer was its weakest build.Terminal-Bench-Science.Frequently Asked Questions (FAQs)
Is GPT 6.2 Sol good for coding?
Yes, for most everyday app work. It scored 87.62 percent on Vals Vibe Code Bench, about 2 points behind Astra, and my five builds scored 20.1 out of 25 with zero page errors on first load. Artificial Analysis did find its Coding Agent Index 3 points lower than GPT 6.1 Sol, so test it on your own repo before you switch.
Should I use GPT 6.2 Sol or GPT 6.2 Astra?
Use Sol for most builds, reviews and revisions, and switch to Astra for long, hard projects like 3D scenes, CAD tools or science work. OpenAI's own help page suggests Sol for reviewing pull requests and revising code, and Astra for tracing bugs across services. Astra costs four times as much per token.
How much does GPT 6.2 Sol cost?
The API charges $2 per million input tokens, $0.10 for cached input and $10 per million output tokens, the same as GPT 6.1 Sol. Prompts above 272K input tokens cost 2 times as much for input and 1.5 times as much for output. Batch requests cost half.
Can I use GPT 6.2 Sol in regular ChatGPT?
No, not in the regular Chat view. You open Work or Codex on a Plus, Pro, Business, Enterprise or Edu plan, according to OpenAI's help page. New Work chats start Sol at Light effort, so raise it for anything serious.
Which reasoning effort should I use for GPT 6.2 Sol?
Medium or high covers most work. On Artificial Analysis, Sol scores 53 at medium, 55 at high and only 57 at max, so the top settings add little. I used Ultra in the Codex app, which also lets Sol hand parts of a build to subagents.
Can GPT 6.2 Sol generate images?
Not by itself, because Sol only outputs text. In Codex and ChatGPT it calls OpenAI's built in image generation tool, which made the textures, art and illustrations in my builds. Apps that use Sign in with ChatGPT cannot generate images through your plan yet.
Final Thoughts
GPT 6.2 Sol earned 20.1 out of 25 from me, close to the 21.1 Astra scored on a different set of builds, at a quarter of the price per token. Every app it built ran without a single page error, its generated images were the best part of the whole test, and its misses look like polish problems a developer can fix quickly.
For most builders, Sol is the default model to start with, and Astra is the one to switch to for hard 3D, physics or science work. Pick one of the prompts above, run it on Sol at high or Ultra, and spend the time you save on the last ten percent of polish.





