GPT-6.2 Astra: What the Leaks and Early Tests Tell Us About AI Agents

A2Agent Team · 2026-11-14T00:00:00Z

OpenAI hasn't announced GPT-6.2. As of November 14, 2026, there's no GPT-6.2 post in OpenAI's newsroom, no entry in its API changelog, and no published price, benchmark or release date. The newest model OpenAI has documented is GPT-6-Cyber, added on November 5.

Over the past two weeks, though, the name has turned up in Codex usage data, briefly in OpenAI's API model list, and in dozens of test posts on X from people who say they were routed to it. None of this is confirmed. Taken together, it still shows where OpenAI seems to be heading: models that run long tasks inside their own execution environment, instead of answering one prompt at a time.

What's confirmed and what isn't

Status
GPT-6 Astra (gpt-6-astra) Released September 3, 2026. $10 input / $50 output per 1M tokens
GPT-6.1 Sol Released. $2 input / $10 output per 1M tokens, about 1.05M-token context
GPT-6-Cyber Added to the API changelog on November 5
GPT-6.2 Astra or Sol Not announced. No price, specs, benchmarks or date
gpt-6.2-astra in Codex usage data Reported from screenshots, not verified
rc-ada-or-vm and rc-ada-sh-vm in the API model list Reported by 36Kr; removed within minutes
"Models 6.2 and later" in OpenAI's docs Appeared on November 10, then removed the same day

The two-VM clue

According to 36Kr, two model IDs, rc-ada-or-vm and rc-ada-sh-vm, appeared in OpenAI's API model list on November 4 and were removed minutes later. Developers who tried to call them got a capacity error. The community read "rc" as release candidate and "vm" as virtual machine, and guessed that one handles planning and orchestration while the other runs code and commands in a sandbox.

OpenAI hasn't said what these IDs are. The idea behind the guess is worth taking seriously anyway. In an agent system, the model works out the goal, breaks it into steps and coordinates the work, while the environment runs code, reads files and calls tools. Splitting the two makes it easier to keep track of state, stops one task from interfering with another, and gives a clear place to draw permission boundaries. How capable an agent is then depends on the model and on how well it works with its environment.

Codex labels and silent routing

TestingCatalog reported a gpt-6.2-astra entry in Codex usage analytics in early November, while the model picker still showed GPT-6 Astra. Screenshots shared on November 4 showed gpt-6.2-astra and gpt-6.2-sol labels on what was described as a Google Cloud quotas page. From November 8, some users said their GPT-6.1 Sol requests were being routed to a newer model. Kie.ai described that as consistent with a staged A/B test.

A label in one account's usage chart doesn't tell you how much traffic a model gets across Codex. The pattern matters more than any single number. AI products are moving toward one entry point that routes each request to a different model and reasoning setting depending on how hard the task is, how fast it needs an answer and what it can cost. For developers, choosing a model is slowly turning into choosing a whole system.

What people are testing on X

Most of the public evidence comes from developers on X who say they were routed to GPT-6.2 during testing. Five widely shared posts give a sense of what they saw.

The pelican test

On November 1, agent architect @FiniYang said he'd been given access to GPT-6.2 Astra and ran the community's pelican-on-a-bicycle test, asking for a 360° animation of a pelican riding a bike. The post passed 200,000 views. Replies were split between people calling the result unbeatable and people who saw little improvement.

@FiniYang's test of GPT-6.2 Astra using the pelican-on-a-bicycle prompt

View the original post

"It made this video itself"

On November 3, @TokenGremlin, who tracks model leaks, posted a video captioned "GPT-6.2 Astra is waking up, and the competition should be worried," saying the model made it on its own. It drew 146,000 views. Replies pushed back quickly: @LuminaBench said it was only video generation, not something the model produced in code, and @CodeByNZ guessed Astra had called one of OpenAI's video models. During testing, it's easy to credit a language model with output that another model in the same system produced.

@TokenGremlin's post claiming GPT-6.2 Astra generated a video by itself

View the original post

Astra vs Fable 5.5

On November 2, @leo114119 ran the same prompt for a 2D anime-style scene on GPT Astra, which he suspected was the 6.2 test build, and on Fable 5.5, asking each for a single self-contained HTML file. His verdict was that Astra can now produce a complete animation, and that "generating animation through code has been genuinely usable since Fable 5.5," but that the two were "not even at the same level" on detail and scene design. @TokenGremlin replied that the model being tested was GPT-6 Astra, not 6.2. When model names are hidden during testing, people can't even agree on which model they're looking at.

@leo114119's side-by-side comparison of Astra and Fable 5.5 on the same anime scene prompt

View the original post

Sol in Three.js

On November 8, @TokenGremlin posted two more tests after being routed to GPT-6.2 Sol. The first was a black hole scene rendered on the first try, which he said beat Claude Opus 5.5 on design and 3D work. The second was a full Japanese village with cherry blossoms, a river and windows lighting up as day turns to night, all written in Three.js inside one HTML file, with no Blender and no outside 3D assets. He called GPT-6.2 Sol "far stronger than GPT-6 Astra, while noticeably cheaper."

A Japanese village scene that @TokenGremlin says GPT-6.2 Sol built in Three.js in a single HTML file

View the original post

"The tests blew up"

AI blogger @xiax0603 summed up the mood: "GPT-6.2 Astra is here too, and the test build blew everyone away," adding, "At this level, how is Fable 5.5 supposed to keep up?"

@xiax0603's post on the community reaction to GPT-6.2 Astra tests

View the original post

How to read these tests

Almost all of them are creative coding: Three.js scenes, front-end animation and 3D rendering. That fits the theme of this post, because each one asks the model to plan a structure, write code that runs and deliver a finished result.

Opinions range from "state of the art" to "not much better," which suggests the test builds aren't stable yet, and one demo doesn't prove much. Model names are also a mess. GPT-6 Astra and GPT-6.2 Astra get mixed up, and output that may have come from a video model gets passed around as proof of coding skill. From the outside, it's hard to know which model, or which system, produced what you're looking at. That's a good argument for judging agents on repeatable, task-level tests instead of demos.

From token price to cost per finished task

Agents also change how you should compare prices. API pricing is per input and output token, but a real agent task runs many rounds of reasoning, tool calls, code execution and fixes. A model with a lower token price can still cost more if it needs several tries to finish.

The number that matters is the cost of a successfully finished task. It includes the tokens, the tool calls, the retries, the failures and the time a person spends fixing the result. A model that costs more per call but finishes reliably can be cheaper overall than a cheap one that needs a person to clean up after it. If @TokenGremlin is right that GPT-6.2 Sol is both stronger and cheaper than GPT-6 Astra, that's the comparison that will decide whether teams switch.

More access means tighter limits

An agent that can read files, run commands and call APIs can do real damage with one bad decision. As models get better at acting, permissions, isolation and audit logs have to keep up.

An agent should stay inside the permissions it's given and not widen its own access because a task seems to need it. Important actions should leave a record you can check. A model can't enforce that on its own just by following instructions, so the tools and the execution environment have to enforce it too.

What to watch for

Until OpenAI publishes something, GPT-6.2's architecture, performance, price and release date are all unknown, and leaked labels and demo videos can't tell you how the final product will behave. The direction is clear, though. Reasoning is still the foundation, but planning, tool use, the execution environment, state, permissions and cost will decide whether an agent can handle real software and business work.

For developers, the question is shifting from which model is smartest to which model and execution system can finish real tasks at the lowest total cost and the highest success rate. We'll update this post when OpenAI announces GPT-6.2.

Test agent workflows on A2Agent

A2Agent gives you DeepSeek, GLM, Kimi, MiniMax, Qwen and other models through one API key, with OpenAI-compatible and Anthropic-compatible endpoints, so you can run the same agent tasks across models and compare cost per finished task. See the Models page for current availability and prices. New accounts get $5 in free credit.

Sources