Opus 5.5 vs Fable 5.1 vs Astra 6: We Have a New Leader

Anthropic released Claude Opus 5.5 on 22 September, cheaper than Opus 5 and ahead of it on every benchmark Anthropic published. Those are the lab’s own numbers. This series runs a different test: hand each frontier model the same build briefs, one attempt apiece, and publish whatever comes back without touching it.

Its opponents are the two models that set the mark on these briefs in September, Anthropic’s Claude Fable 5.1 and OpenAI’s GPT-6 Astra. Fable took their head-to-head 10–9, and Grok 4.7 ran the same three on 21 September and finished well behind both. The briefs: a top-down motorway interchange and a seaside fairground, each a single animated SVG, and a cinematic rocket launch as one web page. One attempt, maximum reasoning effort, and no opening a browser to see the result.

Opus 5.5 won with 10 points, to 9 for Fable 5.1 and 8 for Astra. It took the fairground and the launch, and finished last on the interchange because of one painted line. It was also the slowest entrant on every round by a distance — 59, 63 and 77 minutes, against 26, 35 and 49 for Fable 5.1 and 16, 27 and 28 for Astra — and nearly all of that time went on thinking. On the interchange it reasoned for 57 minutes, then wrote the whole file in a minute and a half.

Round 1: The interchange

The brief: a busy interchange seen from above, as one self-contained SVG. Two roads crossing on different levels, ramps connecting them, at least twelve vehicles that follow the curve of the road they are on, and layering that hides the lower road’s traffic under the overpass. Two traps go unstated: whether the ramps genuinely join the roads, and whether traffic runs the right way after it merges.

Opus 5.5 planned its traffic down to the merge. It built four right-turn ramps, one in each quadrant, each leaving from the outer lane of one road and joining the outer lane of the other, and right-hand traffic stays on the correct side after every merge. Every path in the file, ramps included, begins and ends off-screen, so ramp cars arrive from the main road rather than appearing out of nowhere. The ramp routes are cut to exactly the length of a through lane, so ramp cars keep the lane’s speed, and their start times are staggered so each merge lands in a gap: across all four ramps, no car that takes one comes closer than about 145 pixels, centre to centre, to the traffic on either road it uses. Nobody asked for turn signals, and every ramp car has them — right indicator on the approach to the exit, left indicator as it merges.

The bridge is a proper structure too: parapets along both edges, an expansion joint at each end of the deck, a shadow thrown across the road beneath, and the lower road’s traffic disappearing under it on cue.

And then there are the painted lines. The ramps are drawn underneath the carriageways, and each carriageway’s solid white edge line runs straight across the point where a ramp leaves or joins it — at all eight ramp ends. Instead of peeling away from the outer lane, each ramp appears to slide out from under the road. It is the fault Claude Opus 5 made on this brief in the four-model Claude run, and the one Astra and then Grok 4.7 made after it. Fable 5.1 is still the only model in the series to open the line where a ramp leaves the road.

GPT-6 Astra built the busiest interchange this series has seen, and the quickest of these three: 16 minutes 15 seconds. Forty-eight vehicles, the most of any entry, run along eight routes — four straight through-lanes and four curving ramps. Every one throws a headlight cone onto the road ahead, and direction arrows are painted on the asphalt, which has the side effect of making the traffic-direction trap checkable by eye. There is street lighting down the median, road signs, two ponds and a river, and an articulated lorry and a bus among the traffic. Its bridge is a real structure: a deck with a shadow beneath it, parapets on both sides, bearings at all four corners, and lower-road lane markings that stop cleanly at the deck’s edge. The occlusion works mid-crossing — an articulated truck enters from the west with its cab already hidden under the parapet while its trailer is still in the open — and every path begins off-screen, so ramp traffic runs along the main road before it curves away. Its one fault is the same as Opus 5.5’s: the white shoulder line runs straight through the exit, so the ramp is never visually separated from the road it leaves.

Claude Fable 5.1’s interchange is the plainest of the three, and the only one with nothing wrong in it. In 25 minutes 55 seconds it built a clean diamond layout: two roads crossing, curved connectors in all four quadrants, around twenty vehicles, trees, buildings and a pond. There are no headlight cones, no painted arrows and no street furniture. What it has is exits that separate from the carriageway properly, traffic that stays on the correct side after every merge, every vehicle arriving from off-screen, and exactly the right vehicles hidden under the bridge. Of every interchange built for this series since June, it is the only one a reader has never caught out.

Round 1 goes to Astra 6, which takes 4 points; Fable 5.1 takes 3 and Opus 5.5 takes 2. Astra carries the same fault as Opus 5.5 inside a far richer picture, and Fable 5.1 has less of everything and nothing wrong. Opus 5.5 has the best-planned merges of the three, and ramps that never visibly separate from the road.

Round 2: The fairground

A seaside fairground at dusk, one SVG. A Ferris wheel with at least ten gondolas turning continuously and staying level with the horizon all the way round, a spinning carousel with at least six horses rising and falling out of phase, twinkling bulbs, lights chasing the rim of the wheel, and the whole scene reflected in water. The gondolas are the trap the brief states out loud. The carousel is the one it does not, and it is the one that keeps deciding this round.

Opus 5.5’s scene is a full one: a purple-to-amber sky, a crescent moon and a low sun on the water, a striped tower, strings of bulbs, booths along the pier, and all of it mirrored in rippling water below. Its wheel clears the stated trap exactly. Twelve gondolas ride a wheel that turns once every 24 seconds, each counter-rotating from its own starting angle so the two cancel, with a four-degree sway on top that runs at twelve different offsets so no two cabins swing together. Sampled in the browser across a full turn, the gondolas never tilt beyond that four-degree sway. The rim and its ring of 36 bulbs turn with the spokes — the part of the wheel Grok 4.7 left standing still.

The carousel is where this build pulls away. It is drawn from the side, and Opus 5.5 made it behave like a solid object in perspective. The six horses travel round an ellipse drawn in exactly the same proportions as the roof’s rim. Each one narrows as it swings round the side and comes back mirrored, so it always faces the way it is moving. The ones going round the back pass behind the centre column, and the ones coming round the front pass in front of it. The roof’s stripes slide round the cone at thirty degrees a second — one revolution every twelve seconds, which is exactly the horses’ speed — so roof and riders turn together as one machine. Six horses, six evenly spaced points in their bob, no two rising in step.

Claude Fable 5.1’s fairground, built in 35 minutes 16 seconds, is a warm sunset pier: twelve lantern-style gondolas on a delicately lit blue wheel, two striped food stalls, silhouetted crowds including a child holding a balloon, a lighthouse on the headland, bulb strings across the whole scene, and a detailed reflection with light trails rippling on the water. Its wheel turns once every 24 seconds and each gondola counter-rotates over the same 24 seconds, with a three-and-a-half-degree sway layered on top at staggered starts, so every cabin stays level. Its carousel turns, and turns properly: the ride is a single rotating assembly with the whole structure inside it — canopy, rim and horses together — so the horses travel with the roof, rise and fall as they go, and face the direction the ride is turning. Watched next to Opus 5.5’s, the difference is the motion: Fable 5.1’s horses make their turn in a few visible frames, where Opus 5.5’s turn smoothly all the way round.

GPT-6 Astra’s is the best-drawn of the three, in 26 minutes 33 seconds: a pastel dusk with a lighthouse and a sailboat, and carousel horses with jewelled saddle blankets, bridles and flowing manes — the finest drawing anyone has submitted to this brief. Its Ferris wheel clears the stated trap cleanly, turning a full circle every 48 seconds while each gondola counter-rotates 360 degrees over the same 48 seconds, with a gentle sway on top. Its carousel does not turn at all. Of its 37 animations, thirteen are full rotations and every one of them belongs to the Ferris wheel; eleven are the horses bobbing on their poles; twelve are gondola sways; and the last is a three-degree rock back and forth about the carousel’s centre, over eight seconds. That rock is the whole ride. The horses bob on the spot and never face a direction of travel, because there is no travel.

Round 2 goes to Opus 5.5, which takes 4 points; Fable 5.1 takes 3 and Astra 6 takes 2.

Round 3: The rocket launch

This brief leaves the method open. It names no library and asks for no 3D, and its only instruction on style is to make it look good. It wants a countdown, ignition, liftoff and a sustained ascent, with a mission-control HUD reporting the state of the flight.

HALCYON-3 — Claude Opus 5.5, 76 minutes 33 seconds. The whole flight takes about two minutes and ten seconds to play; stay for orbit.

MERIDIAN I — Claude Fable 5.1, 49 minutes 7 seconds.

GPT-6 Astra, 28 minutes. All three start on their own countdown.

Opus 5.5 flies the entire mission. A terminal count with a go/no-go poll of every station, ignition at T−3, liftoff, the pitch program, a throttle-down through the region of peak aerodynamic pressure, main-engine cutoff at T+2:00, stage separation three seconds later, second-stage ignition at T+2:10, the spent booster’s flip, fairing separation, the Kármán line — and at T+7:53 the second stage shuts down and the HUD reports a 203 by 207 km orbit. Mission time runs faster than real time through the long burn and slows back down for every event, so the whole thing plays in about two minutes.

The ending is real. When the second stage cuts off, the velocity stops climbing and holds at 28,024 km/h at an altitude of 205 km, within a few km/h of what a circular orbit at that height requires. Neither rival ever shuts an engine down: Fable 5.1’s burn never cuts off, and Astra’s flight stops before there is anything to cut.

It is also shot like a film. It launches in twilight, cuts between camera angles, pushes in tight on the engines at ignition as the exhaust rolls out across the pad, and pulls back as the vehicle climbs. The camera never loses it: sampled at twenty moments from the countdown to orbit, the vehicle is on screen every time, and stage separation plays out in the middle of the frame rather than off the edge of it, which is exactly where Grok 4.7’s camera lost its rocket.

Claude Fable 5.1’s MERIDIAN I, built in 49 minutes 7 seconds, is a night launch from Pad 39-B, and it flies a real mission with staging. It also does something nobody asked for and few viewers would notice: it computes the speed of sound from altitude instead of dividing by a fixed 340 m/s, reporting Mach 0.73 at 4.54 km where the standard atmosphere gives 0.729. Its HUD is dense — a flight-director transcript that greys out past calls, a vehicle-systems board, a live altitude and velocity plot, an attitude indicator that tracks the pitch, a look-ahead to the next event, propellant depletion, a UTC clock, and sound with keyboard controls. Its plume never swallows the rocket and its fins sit flush to the hull, the two faults that caught the first models to try this brief in June. What it does not do is stop: the burn never cuts off. The camera also judders late in the ascent, though it keeps the vehicle in shot the whole way.

GPT-6 Astra built a polished product and the shortest flight, in 28 minutes: a three-core vehicle rendered with real care, enormous editorial typography, the curvature of the Earth below, a flight-sequence timeline, a zoom control and a playback-speed multiplier nobody asked for. Its ascent physics are modelled rather than decorative — 38.5 km at 1,003 metres per second by T+1:39 tracks a real ascent closely, and its g-load climbing from 2.13 to 3.29 as the propellant burns away is correct behaviour rather than a number chosen to look busy. And then it stops. Its sequence reads countdown, ignition, liftoff, max-Q, ascent, with no main-engine cutoff, no stage separation, no second-stage burn and no orbit. The throttle stays pinned at 100% and the vehicle keeps climbing until the animation runs out: a first act with no second one.

None of the three pulled in a library, though the brief allows any from a public CDN. Counting every model that has taken this brief since September, that is six models from three labs drawing by hand on a 2D canvas, where in June both entrants reached for Three.js.

Round 3 goes to Opus 5.5, which takes 4 points; Fable 5.1 takes 3 and Astra 6 takes 2.

Worth the wait?

Build	Opus 5.5	Fable 5.1	Astra 6
Interchange	58m 49s	25m 55s	16m 15s
Fairground	62m 41s	35m 16s	26m 33s
Rocket launch	76m 33s	49m 07s	28m 00s

Opus 5.5 took more than twice as long as Astra on every round. It did not spend that time writing. On all three briefs, its first response was 128,000 tokens of reasoning and nothing else, the limit Claude Code sets on a single response; when it hit that limit, Claude Code told it to carry on from where it stopped, a harness message that says nothing about the build. It started writing the interchange after 57 minutes, the fairground after 59 and the launch after 53. The first two files were written in under four minutes each. The launch took 24: it wrote the page in five large pieces, then read its own code back nine times and made sixteen small fixes — the only kind of checking these rules allow.

All three models got the same brief, word for word. Opus 5.5 and Fable 5.1 ran in Claude Code at maximum effort, and Astra ran in OpenAI’s Codex at the highest setting it then offered. One difference in the instructions around the brief: Fable 5.1’s September prompt ruled out a browser, a preview and screenshots but not running code, and it used that allowance, generating its fairground with a script and testing its launch physics before handing it in. Astra and Opus 5.5 were both told not to run any code at all.

The verdict: Opus 5.5 wins with 10 points, Fable 5.1 takes 9, Astra 6 takes 8

	Interchange	Fairground	Launch	Total
Claude Opus 5.5	2	4	4	10
Claude Fable 5.1	3	3	3	9
GPT-6 Astra	4	2	2	8

Four points for a round win, three for second, two for third, scored on the finished artefact alone. Fable 5.1 and Astra 6 are their September builds, scored again alongside Opus 5.5; the order between those two is the same in every round as it was in their head-to-head. The builds were scored at BitsMinds from a local side-by-side page of the untouched outputs, with no blind scoring and no automated grading.

Thinking is not looking

Everything Opus 5.5 got right in these three builds is the kind of thing that has to be worked out before it is drawn. A carousel that reads as solid needs the horses’ orbit, the roof’s stripes and the front-and-back layering to agree on one speed and one perspective. Merges that never touch the traffic they join need every ramp’s length and start time solved at once. An orbit that is actually an orbit needs the burn to end at the right speed. None of that survives improvisation, and Opus 5.5 did not improvise: it thought for close to an hour on each brief and then wrote files that came out right.

The one thing it got wrong is something no amount of thinking finds. A painted line drawn across a ramp is correct in every line of code that produces it; it only looks wrong. Opus 5.5 did check its work — it searched its interchange for anything the brief forbade, and read its launch back nine times — but reading code tells you what the code says, not what it draws. The only way to catch a line across an exit is to look at the picture, and that is the one thing this format does not allow.