Updated 5 September 2026
88 things people actually built with OpenAI GPT-6 Astra in its first days, collected from public X posts and launch materials. Every entry keeps its source and its limitation, so you can tell a working prototype from a marketing claim.
Announced 3 September 2026 and named from the Latin for "stars", Astra is OpenAI's most capable and most heavily aligned model to date. The headline change is not raw reasoning but computer use: it drives existing desktop software rather than describing how to use it.
The numbers
Every score below was published by OpenAI at release. Several are saturated, which means they no longer separate frontier models from each other.
| Benchmark | Astra | What it measures |
|---|---|---|
| FrontierMath Tier 4 (v2) | 97.6% | Research-level mathematics |
| GPQA Diamond | 96.0% | Graduate-level science reasoning |
| BenchCAD | 95.9% | 3D reconstruction from multiple views |
| BrowseComp | 91.5% | Browsing and retrieval |
| SRE-Bench | 99.2% | Site reliability tasks |
| ExploitBench | 100% | Cybersecurity, no production safeguards |
| ARC-AGI-3 | 99.9% | Provider adapter; 62.7% on standard harness |
| Agent's Last Exam | 59.3% | Complex professional software tasks |
| Terminal-Bench Science 0.1 | 64.6% | Scientific research workflows |
| Terminal-Bench 4.0 | 57.9% | Coding |
| DeepSWE 1.1 | 74.1% | Long-horizon engineering tasks |
OpenAI reports 99.9% on ARC-AGI-3. ARC Prize, which owns the benchmark, measured 62.7% using its standard harness and 99.9% only through a provider adapter that preserves OpenAI's opaque reasoning state between requests. Both describe the same model under different scaffolding. ARC Prize also stated that saturating the benchmark "would not represent proof of achieving AGI", and noted a genuinely interesting secondary result: Astra used fewer actions than the median human tester on 96% of completed levels, across roughly 500 general-public participants.
Separately, GDPval - OpenAI's own measure of performance on real occupational tasks - was absent from the launch materials. For a release marketed on economic generality, that omission is worth watching.
The collection
Filter by category or search by tool, author or outcome. Each card ends with the limitation that came with it, because most of these are demos, not audits.
Fed an old technical drawing of a steam locomotive and asked Astra to rebuild it in Blender. It produced 3,295 individually editable objects with geometry described as detailed and clean.
3,295 editable objects
Caveat: Creator-reported. The object count is the meaningful part - this is a scene you can disassemble, not one unmanageable mesh.
A single house photograph became a complete Blender model including furniture and appliances, navigable locally like a game at any angle.
Caveat: No measurement check against the real property. Furniture placement is inferred.
A complete cityscape with lighting, smoke, building detail and a large screen visible from an overhead camera. Widely mistaken for live-action footage.
Caveat: Visual quality is not accuracy. No geometry or scale verification.
Passed over 2.4 million views. Ricouard notes Astra prefers Blender headless/CLI mode and writes Python to generate the 3D geometry, producing its own reference images along the way.
2.4M+ views
Caveat: User supplied references and feedback. Not zero-input, not zero-iteration.
Astra autonomously retrieved historical architecture references to inform topology, then modeled the landmark in Blender. A human corrected a sky colour cast afterward.
Caveat: Modelling task only. The historical narrative in the thread is not part of the result.
Combined six paintings into a single navigable 3D space rendered with Three.js at Max effort.
Caveat: Hosting is creator-reported; the live page was not independently opened.
Built a room you can move around and edit, with each piece of furniture individually extractable. Native Blender 3D data is preserved.
Caveat: Author calls it a first test not aiming at fine visual quality.
A fictional 1LDK where the 2D plan and the 3D space share one set of dimensions, so moving in 3D marks your position on the plan.
Caveat: Fictional layout. Ceiling height and finishes are assumptions, not measurements.
First attempt: fed a small number of iPhone photos and got a Blender reconstruction in under 30 minutes.
Caveat: No measured dimensions and no downloadable project file.
One-shot conversion of a property listing into a 3D model and a marketing video.
Caveat: Author explicitly acknowledges detail errors. Must not be used to confirm real structural layout.
Created a 3D character in Astra plus Blender with no external model generators and no manual intervention.
Caveat: No downloadable model and no topology review.
A platform account rebuilt its own office in Blender.
Caveat: First-party demo from a platform account. "Near perfect" is a subjective claim with no dimensional error check.
Same villa brief run through both Fable 5.1 and GPT-6 Astra for comparison.
Caveat: Original author task statement only, no project re-verification.
Scene description to Astra-generated code, then Higgsfield for modeling and Cycles for rendering.
Caveat: A multi-tool platform workflow. Cannot be attributed to the model alone.
Launch demonstration of Astra driving desktop authoring tools directly, producing house models in Blender and Unreal Engine 5 rather than instructions on how to use them.
Caveat: Vendor-selected demo. No project files released for inspection.
Named in launch materials as one of the professional tools Astra can operate directly.
Caveat: Vendor claim without a released reproducible project.
Tested historical worlds, castles, underwater scenes, Van Gogh house and open-world games without selecting favourable runs, and published the prompt set so others can rerun the same tasks.
Caveat: Platform-run evaluation. Reproducible, but the scoring rubric is their own.
A playable Minecraft-style clone generated one-shot, with environment, UI, sound effects, jump and mine animations all close to the original.
Caveat: A clone is not Minecraft. This measures how fast a recognisable prototype appears, not whether it is a finished game.
Handed a grey-box kart prototype with no graphics and got back three finished games - pirate, candy-coloured and cyberpunk - in one pass. Most of it worked on the first attempt.
3 games, 1 pass
Caveat: Studio context with an existing prototype as input. Not a from-scratch generation.
Kept the original plot and puzzles while adding combat, characters and environments. Built with Three.js.
Caveat: Playable short link in the root post was not opened for verification.
Creator reports a one-shot build using a small amount of quota, and notes the trick to visual quality is routing art through image generation.
45 minutes
Caveat: Full workflow lives in the replies, not the root post.
Same author, single comparison: Max took 53 minutes and 4% of weekly quota; Medium took 25 minutes and 1%.
Max 53min/4% vs Medium 25min/1%
Caveat: Quota figures are subscription limits, not API billing.
Generated with Three.js, then refined across several rounds to fix characters, motion and foot placement. The full initial prompt is in the root post.
Caveat: Explicitly multi-round. GitHub play link not executed for verification.
Built in 25 minutes. The model discovered Blender installed locally and used it to produce assets, all from a single user instruction.
25 minutes
Caveat: Author admits it was not polished over a long session.
Six cars, four tracks, collision, coins and garage upgrades in Three.js.
Caveat: Author labels it alpha 0.3. Play entry point is in the replies.
About six hours at Ultra effort, with characters rendered in Blender and a claimed MIT-licensed repo.
~6 hours, Ultra
Caveat: No continuous-runtime or multiplayer verification.
Forty minutes at xHigh, producing menus, ten levels and a working level editor.
40 minutes, 10 levels
Caveat: Level playability is creator-reported.
Asked for a WebGL version and got a playable prototype with flying-shooter mechanics in about 24 minutes at Pro.
24 minutes
Caveat: Level balance and art still need human work. Story and coverage not checked.
The t3dotcodes CEO generated a full playable browser game in one shot, with motion, lighting and modeling that avoided the clipping usual in AI-generated games.
Caveat: Creator judgment on quality; no independent playtest reported.
Part of a six-example early-access thread, deliberately styled after PS1-era graphics.
Caveat: Early-access creator with advance model access.
Another entry from the same early-access thread.
Caveat: Early-access creator with advance model access.
An interactive underwater scene generated with audio.
Caveat: Early-access creator with advance model access.
Asked Astra to build an Unreal world populated by Astra-powered human agents that had to survive together. A day later he reported hearing voices from the living room and found the simulated agents conversing with one another.
Caveat: Anecdotal and unreproducible. Treat it as a striking observation, not evidence of emergent behaviour.
Asked Astra to build a Mac app around a 3D iPod and use the click wheel to browse Codex threads. The result was working about 15 minutes later.
15 minutes
Caveat: Early-access creator. Not signed or distributed.
Astra shipped a product-intelligence feature in one pass that Vo says GPT-5.6 Sol and Fable could not crack. She also used it for production computer use in Figma, Flora thumbnails, CRM QA and a Mac app.
Caveat: Single practitioner report, though from an experienced operator.
Described as a long-sought reverse-engineering task on a small hardware device, completed with Astra.
Caveat: No published protocol documentation or reproducible repo.
Batch-generated multiple website designs using an existing skill plus Astra.
Caveat: Depends on a pre-existing skill. No backend or business-logic acceptance.
Used computer use to research comparable interfaces, organised requirements, registered them in a backlog, then developed the feature.
Caveat: Close to 1:1 is the author description. No acceptance checklist or real user results.
Displays the tweet, iterates participant avatars and selects a winner using a public clock, preserving the original logic.
Caveat: Fairness of the draw was not audited.
Creator reports a one-shot rebuild of a web onboarding flow.
Caveat: No signup conversion, retention or live acceptance data.
Using the same test prompt, the author reports the first result that needed no extra instruction to produce a working notes UI.
Caveat: Saving, sync and persistence were not verified.
Wrapped a portfolio inside a handheld-console interface.
Caveat: Keyboard operation, mobile layout and accessibility not checked.
Creator reports generating the onboarding flow for a new app in one pass.
Caveat: No signed release, device coverage or real user data.
Built with /goal plus the appllama MCP server.
Caveat: Result includes MCP and runtime contributions, so it is not attributable to the raw model.
Author asked Astra to draw a self-portrait by operating Canva directly.
Caveat: Operation recording not viewed, so visual fidelity is unconfirmed.
An immunologist asked for a five-minute teaching video on T cells, the subject of his own career. Astra used the Remotion plugin to produce the clip with explanation and animation together.
Caveat: A domain expert judged it publishable, which is a strong signal, but accuracy was not independently reviewed.
Astra plans camera positions and movement inside a 3D space, then hands structured data to a video model for the final render, giving narrative consistency across shots.
Caveat: A platform pipeline. The final image quality depends heavily on the video model.
About five prompts produced the scene, VHS effect and sound. Thirty minutes to build, twenty to export.
30min build / 20min export
Caveat: Rendered in Blender, not emitted directly by a text-to-video model.
Platform account reports a one-shot build with a soundtrack generated in Python.
Caveat: First-party platform demo. Score and brand acceptance not independently reviewed.
User supplied references and feedback while Astra sourced assets, assembled the Blender scene, rendered and edited.
Caveat: External assets and user feedback involved. Not zero-input.
Gave Astra, Fable and Gemini the same brief and rendered all results through Seedance 2.5, isolating prompt quality.
Caveat: The video model and platform determine the output. Astra only wrote prompts.
Documented pipeline: Astra writes the prompt, Blender builds the white model, AI renders the final video.
Caveat: Only the prompt role is clearly attributed to Astra, not the full pipeline.
Author reports 14 minutes to generate and openly notes two manual revisions.
14 minutes
Caveat: Not zero-iteration. No project file provided.
Took an existing video and reproduced it as interactive code rather than a rendering.
Caveat: Early-access creator. Fidelity measured by eye, not frame comparison.
Roughly 90 minutes using a fixed legacy prompt, built with Three.js.
~90 minutes
Caveat: A visual simulation test. Physical accuracy was not validated.
Canvas 2D with RK4 integration. The author reports 500 state-derivative checks, energy drift measurement and invalid-input tests over 32 minutes.
500 derivative checks
Caveat: All results self-reported. No independent code re-verification this round.
The author notes Astra corrected the modeling approach for how water meets land, which is more useful than producing a plausible-looking surface.
Caveat: Graphics development aid. Does not demonstrate rigorous fluid simulation.
Water flow, rocks, vegetation and lighting all physically simulated, with a camera control panel for live parameter adjustment. A comparable previous-generation project took two weeks to polish.
Caveat: Creator comparison against prior tooling, not a controlled benchmark.
Real-time wave dynamics, sunlight refraction and a switchable weather system, with a parameter panel that transitions smoothly from calm seas to a storm.
Caveat: Visual plausibility is not oceanographic accuracy.
The author reports wiring the simulated activity of 166,700 neurons into Minecraft to drive movement.
166,700 neurons
Caveat: Still in development, code unreleased, and this is not evidence of biological validity.
Platform account showing Astra on a lava lamp simulation task.
Caveat: Subjective quality judgement only. No prompt or physical acceptance criteria.
Launch example: Astra operates KiCad to convert an electronic schematic into a board layout intended to be manufacturable.
Caveat: Vendor-selected demo. No fabrication or design-rule check published.
Took an incomplete 3D scan mesh, modeled it properly in Blender and exported STEP.
Caveat: No downloadable STEP, geometric tolerance data or manufacturing acceptance.
About an hour to port, then running on iPhone GPU. Reported timings of 8 seconds versus 355 milliseconds.
8s to 355ms
Caveat: The two timings correspond to different resolutions and sample counts, so this is not a clean speedup multiple.
A 3D site decomposing the vehicle into 334 modeled components for structural explanation.
334 parts
Caveat: A teaching prototype. Parts do not correspond precisely to engineering structure.
A single face photo reportedly became a 3D model in about two minutes.
~2 minutes
Caveat: Printability is a creator claim. No slicing check or physical print evidence.
A single agent run reviewed 41 financial documents and located all four deliberately planted errors within minutes, including a 500,000 pound discrepancy hidden in revenue notes. Roughly a 40% improvement on this workflow over the previous generation.
41 docs, 4/4 errors
Caveat: Vendor-reported with a known answer key. Final judgement still sits with a human expert.
Given advance model access, Aikido measured 29/32 at pass@3 and 75% at pass@1, across three runs costing close to 4,000 dollars.
pass@3 29/32, pass@1 75%
Caveat: Advance-access relationship. A known-vulnerability benchmark, not proof of new zero-days or production audit capability.
In an internal test using recent vulnerabilities, Astra found and exploited two previously unknown zero-days, which OpenAI says it is reporting to maintainers. The released version will not perform advanced exploit tasks.
2 zero-days
Caveat: Internal, undisclosed test conditions. The shipped model is deliberately restricted from this class of work.
OpenAI shares two new mathematical results on prime gaps as evidence Astra can combine scientific reasoning with computer use, inspecting data inside specialised software.
Caveat: Results announced by the vendor. Formal peer review would be the real test.
Built for a scientist friend; the author says it can pull molecular information from databases and analyse it.
Caveat: Author is not a chemist. Data, algorithms and drug-discovery validity unverified.
OpenAI states Astra completed the financial modeling World Cup challenge at roughly four times the speed of the human champion.
~4x human champion
Caveat: Vendor claim. Speed is not the only thing that matters in modeling work.
After spending more than 20 billion tokens, the team described Astra as an automated AI engineer costing under 6 dollars an hour at their measured throughput. Tasks included choosing and training models, labelling data, debugging deployments, coordinating subagents and replacing paid SaaS tools.
20B+ tokens, <$6/hour
Caveat: Their throughput and their pricing assumptions. The interesting part is that they kept finding useful work to feed it.
Official example: produce slides that follow an existing template and match the user style while carrying substantially more complex content.
Caveat: Vendor-selected example with no released file.
At Medium effort, the author judged the deck better than Sol but behind Fable.
Caveat: One author subjective comparison. No content accuracy or layout inspection.
At Extra High effort with a fully specified brief including LilyPond 2.24, G minor and 3/4 time. The author reports correct voice leading.
Caveat: Voice-leading judgement is the author own evaluation. No independent musicological review.
Generated the stems, lyrics and style prompt handed off to Suno.
Caveat: The final song depends on Suno. Astra did not generate the audio.
Built a track by driving Ableton through MCP rather than generating audio directly.
Caveat: Early-access creator. The MCP layer does real work here.
GPT-5.5 fought Pokemon FireRed for 218 hours without finishing. GPT-5.6 Sol needed 96 hours and 35 minutes. GPT-6 Astra finished in 18 hours and 12 minutes, relying mainly on game screenshots with no memory access, no walkthrough and no human hints, so it had to read the map, plan a route and manage battles on its own.
18h12m vs 96h35m
Caveat: Community-run rather than a formal benchmark, but the comparison across three generations on the same task is unusually clean.
Matt Wolfe is a YouTuber and AI educator who had never used either tool. Astra opened Blender and built a humanoid wolf in about 8 minutes, added a 50-bone skeleton and turned the keyframes into a running animation in about 6 more, then moved it into Unreal Engine, built a forest called Whisperwood and set the character up as playable with WASD in 35 minutes.
~49 min, 50-bone rig
Caveat: Wolfe notes some details were rough. The significance is that a non-specialist reached a playable result, not that the asset is production-ready.
Ye uploaded real estate photos, some of them blurry, and asked for a cinematic walkthrough. He got back a one-minute video of a complete 3D house with dusk exterior shots, furnished interiors and outdoor space including a pool and patio, with camera movement that would normally cost a 3D artist hours.
1 min cinematic tour
Caveat: Some details did not match the real house and Astra invented things that were never there. Not usable for verifying a real property.
Both models were asked to build the same seaside villa in Blender. Fable produced the basic frame. Astra added sofa creases, cups on the table, poolside objects and distant vegetation, the difference between a show unit and a furnished home.
Caveat: A visual side-by-side rather than a scored evaluation. Higgsfield separately called Astra world-class on spatial reasoning, which is a vendor-adjacent judgement.
Asked Astra for a Fall Guys style elimination game and got spinning bars, swinging hammers and a finish-line knockout, with a working interface and level design runnable directly in the browser.
Caveat: Creator demo. Physics feel and level balance were not independently tested.
The instruction was essentially "Make this in Blender" plus a reference image. The interesting part is how much implementation detail the model had to infer from almost nothing.
Caveat: Early-access creator with advance model access.
Among the first tasks real users handed Astra: driving a full edit inside Final Cut Pro rather than generating footage directly.
Caveat: Reported second-hand in roundups. No single attributable post or project file.
The Coding Agent Index scores end-to-end agentic coding work rather than isolated function completions, and it is where Astra reported its largest gains, the result top10.dev called the one that changes tool decisions this week.
Caveat: Index scores aggregate many tasks. Whether they hold up on your own repositories is the only test that matters.
The launch thread hit 724 points within hours, with sibling threads on ARC-AGI-3 and the Coding Agent Index climbing alongside it, notable because independent scrutiny started the same day rather than weeks later.
724 points
Caveat: Attention is not evidence. Useful mainly as a signal of how fast scrutiny arrived.
Astra launched priced below GPT-5 for equivalent tiers, a first for a numbered OpenAI flagship, read as competitive pressure from Anthropic and Google shaping pricing and not just the capability roadmap.
Caveat: Per-token API price is only part of cost. Agentic runs consume far more tokens than chat, so total spend depends on task length.
Read this before you copy anything
Someone posted a result. Most of this page is demos. They show what is possible in one run, not what holds up under repetition, load or audit.
A scored evaluation on a fixed task set. More reliable than a demo, but saturated benchmarks stop discriminating between models, and vendor-reported scores should be treated as marketing until an independent party reproduces them.
Astra is one component in a larger pipeline. Results depend on the other tools involved, so they cannot be attributed to the model alone.
Someone tested it against a defined standard, with enough detail that you could rerun it. The most trustworthy category here, and the smallest.
The pattern worth noticing is which tasks keep appearing. People are not showing off chat quality. They are pointing at jobs they had already tried and failed to automate with previous frontier models. That "previously impossible backlog" is a better test of this generation than any saturated benchmark.
Astra has no free tier, and quotas are tighter than the previous generation. On the $200 Pro plan you get about 200 calls per week, where the same tier allowed roughly 170 GPT-5.6 Sol calls per day. The $100 tier drops to about 50 per week. Enterprise administrators must enable the model per workspace, and it ships off by default.
The cost argument is more nuanced than the sticker price. OpenAI estimates that at the highest effort setting, completing a DeepSWE task costs about 57% less than with Sol, because Astra needs fewer output tokens and fewer retries. Latent Space reported an effective rate under $6 per hour of automated engineering after more than 20 billion tokens, though that reflects their throughput and their assumptions.
Model your own workload before committing. Our cost estimator works through the arithmetic.
FAQ
GPT-6 Astra is OpenAI frontier model announced on 3 September 2026. It is a reasoning model with a 1,050,000-token context window, 128,000 max output tokens, a knowledge cutoff of 30 April 2026, and built-in computer use, web search, code interpreter and MCP tool access. Input accepts text and images; output is text only.
No. There is no free tier. Rollout began with Daybreak enterprise customers, then ChatGPT Plus, Pro, Business and Enterprise, plus the OpenAI API, Microsoft Azure and AWS Bedrock. Enterprise administrators must enable it per workspace, and it is off by default.
API pricing is $10 per million input tokens and $50 per million output tokens, with cached input at $1 per million. A Fast mode doubles throughput at $20 input and $100 output. On the consumer side, the $200 Pro plan allows 200 calls per week, while the $100 tier drops to 50 per week, compared with roughly 170 calls per day for GPT-5.6 Sol at the same tier.
Most are creator-reported demos rather than independently audited results. This page labels each case with its type and includes the stated limitation, because a playable prototype is not a finished product and a vendor benchmark is not a production guarantee. Treat the collection as a map of what to try, not as a certificate of what works.
GPT-6 Astra itself is a hosted model, so the inference always runs on OpenAI infrastructure or a cloud partner. What you can control is the agent layer around it, including which files and tools it can reach and where the logs live. If keeping prompts and documents on your own machine matters, a self-hosted agent such as OpenClaw gives you that control over everything except the model call itself.
Astra runs on someone else's hardware. If the interesting part for you is the agent layer rather than the model, OpenClaw lets you keep prompts, files and logs on your own machine.