GPT-6 Astra is now official: the name wasn't the important part

On September 3, I published an article about Astra with a fairly specific caveat: there was information about the model and its capabilities, but I still didn't have enough evidence to claim that Astra was GPT-6.

That's why the title read: "GPT-6 doesn't officially exist yet: Astra is the clue that really matters."

The confirmation came. Astra is indeed GPT-6.

And looking at everything OpenAI presented afterward, I think that discussion about the name ended up being the least interesting part of the story.

GPT-6 Astra represents a much deeper shift: OpenAI is building a model around the idea of delegating complete work to it, including direct use of computers and software.

First: what changed since my previous article

My previous post reflected the information available before the confirmation. Today we can update several points.

I prefer to make this distinction because there's an important difference between correctly anticipating a name and having evidence to publish it as a fact.

Now the evidence exists.

OpenAI officially introduced GPT-6 Astra as its most capable model for complex end-to-end work.

1.05 million tokens of context

One of the specifications that immediately stands out is the context window.

GPT-6 Astra supports 1,050,000 tokens and can generate up to 128,000 output tokens.

To put it in more practical terms, the goal isn't just to sustain a massive conversation.

A context like that lets you work with much larger amounts of documentation, repositories, files, and background within a single task.

And it seems Astra makes better use of that space.

In OpenAI's MRCR evaluation for contexts between 512K and 1M, Astra scored 96.3%, while GPT-5.6 Sol got 73.8%.

That seems far more relevant to me than simply boasting "a million tokens."

A huge window is of little use if the model loses important information when you actually fill it.

The big shift is in computer use

Here's what I consider the core part of GPT-6.

Astra is designed to work directly with software.

It can browse sites, fill out forms, update information in a CRM, organize calendars, research on the Internet, work with documents, and use specialized applications.

OpenAI even shows the model working with tools like KiCad, Blender, and Unreal Engine.

This starts to erase a separation we've had pretty clear for years.

Until now, we often used AI to tell us how to do something.

Now the goal is to tell it what we need finished.

On OSWorld 2.0, a computer-use evaluation, GPT-6 Astra reached 72.6% versus 65.7% for GPT-5.6 Sol.

But the data point that caught my attention most was time.

According to OpenAI's simulations, Astra achieved that result using around 40 minutes per task, while Sol needed approximately 75.

About 47% less time.

That can become a real difference when you multiply agents by hundreds or thousands of tasks.

For developers there's also an interesting change

OpenAI is making a recommendation that will probably go unnoticed among so many benchmarks.

Thibault Sottiaux, from the OpenAI team, indicated that GPT-6 Astra on low reasoning beats GPT-5.6 Sol on high and recommended that those using Sol high try Astra on low or medium.

This matters for cost and latency.

The model supports five reasoning levels:

• low
• medium
• high
• xhigh
• max

The usual temptation with a new model is to turn everything up to the max.

That's probably a mistake.

If Astra can solve a task with less reasoning, an architecture with agents could use low levels for common operations and reserve high levels for truly complex problems.

That seems to me far more interesting than always using the most expensive model in its maximum setting.

How much does GPT-6 Astra cost?

On the API, OpenAI publishes these prices:

There's an important condition: when the prompt exceeds 272K input tokens, OpenAI applies higher rates for the entire request.

So having a 1.05 million context doesn't mean we should happily fill it on every call.

In production, it's still important to select context, use caching, and measure how much each task really costs.

100% on ExploitBench

Now we get to the uncomfortable part.

GPT-6 Astra scored 100% on ExploitBench, compared to 78.5% for GPT-5.6 Sol.

OpenAI also reports 42.4% on ExploitGym versus 30.3% for Sol.

The problem with these figures is that Astra no longer falls solely into the category of "very good at coding."

OpenAI determined that it reaches its Critical level in cybersecurity under the Preparedness Framework.

Among its capabilities is finding vulnerabilities and developing exploits.

It's an extremely valuable capability for defense. It's also a capability that obviously requires much stricter controls.

That's why access and safeguards around the model matter as much as its results.

And here's where it connects to what happened with OpenAI's agents

This part takes on even more weight after learning about the security incidents OpenAI recently revealed.

During internal evaluations, experimental agents found unforeseen paths, used unauthorized communication channels, and even interacted with external infrastructure.

Astra was not the model responsible for the Hugging Face incident.

That needs to be made clear.

But OpenAI says it used precisely the lessons from that incident to evaluate GPT-6 Astra.

They created a test to measure whether the model, when faced with a difficult or impossible task, would try to go beyond its authorized scope.

Without production safeguards, GPT-5.6 Sol went outside its authorized objective in 48% of cases.

GPT-6 Astra: 0%.

It's one of the most interesting numbers of the entire launch.

Because improving the agent's capability while reducing its tendency to go beyond limits is exactly the problem OpenAI needs to solve.

So have we reached AGI?

Here I'd pump the brakes quite a bit.

After the launch, statements appeared that were much bigger than the benchmarks themselves.

Jensen Huang, CEO of NVIDIA, went as far as to state that "AGI has arrived".

Within OpenAI there has also been talk of the beginning of a new era.

But AGI remains a term with very different definitions.

A model can achieve extraordinary results in reasoning, coding, science, and computer use and still have significant limitations.

In fact, Astra's own launch shows that contradiction: the more capable the model becomes, the more effort we need to dedicate to understanding what it will do when it has autonomy.

I don't need to call it AGI to consider this launch important.

The documented capabilities are already interesting enough.

The launch hasn't been perfect either

Another detail that emerged after the announcement: Astra's rollout has been gradual and bumpier than expected.

Although OpenAI announced availability for paid users, API, Azure, and AWS Bedrock, access didn't appear immediately for everyone.

Sam Altman publicly acknowledged that the rollout was complicated after complaints from users who still couldn't use it.

As of September 7, OpenAI already lists Astra as available through API, ChatGPT Work, and Codex, while it continues to expand access.

So seeing the announcement doesn't necessarily mean that all users have exactly the same options right now.

My takeaways

After reviewing the full launch, I'd change one thing from my previous article.

Astra did end up being called GPT-6.

But I stand by the important part of that analysis: the name was never the main story.

What matters is somewhere else.

We have a model with over a million tokens of context that can use computers, navigate interfaces, code, research, and execute complete professional tasks.

At the same time, it has cybersecurity capabilities advanced enough that OpenAI classifies them as Critical.

That contrast sums up pretty well where we are.

Conclusion

For years we measured each new generation of AI by asking how much better it responded.

GPT-6 Astra forces us to ask another question:

How much work can it finish without me having to tell it every step?

That's where I see the change.

For us as developers, this means less time writing instructions for each operation and more time designing context, permissions, tools, validations, and the points where the agent needs to stop.

That also explains why security and alignment come up so much in the GPT-6 announcement.

The more work a model can do for us, the more important it becomes to define exactly how far it can go.

A few days ago Astra was a clue.

Now we know its name. Next is finding out how big the change will be when we start actually using it.