Astra Is Here. Here's What It Is Actually Good At.

If you already use ChatGPT, Claude, or another AI tool, you may be wondering what is actually different about Astra.

That was my question too.

I did not want another list of things AI can already do.

Write an email.

Summarize a document.

Make a PowerPoint.

Brainstorm ideas.

We already have that.

I wanted to know:

What is Astra specifically good at?

And what could someone like an instructional designer actually test it on?

That answer is much more interesting.

First, what is Astra?

Astra is a new AI model from OpenAI, the company behind ChatGPT.

OpenAI announced GPT-6 Astra and began a phased rollout on September 3, 2026. It first went to a limited group of organizations, with wider access rolling out over the following days.

A model is basically the AI brain behind a tool like ChatGPT.

Different models have different strengths.

Some are especially good at writing.

Some are better at coding.

Some are faster.

Some are built for harder jobs.

Astra stands out because OpenAI built it for difficult work that can involve reasoning, software, websites, files, coding, and other tools.

One of its biggest strengths is computer use.

What does "computer use" mean?

It means AI can do more than tell you what to click.

In the right setup, it can look at what is on a screen, figure out where something is, request an action like clicking or typing, see what happened next, and continue working.

There is an important detail here.

Astra does not magically take over any computer you point it at.

It needs an environment that gives it access to the tools it needs.

Inside products such as ChatGPT, that might mean a browser or other tools OpenAI provides.

If a developer is using Astra through the API, software still has to take Astra's requested actions and send the results back to the model.

It also needs whatever permissions are required to access the system you want it to use.

So think:

Astra can be the brain doing the work.

It still needs the right hands, tools, and permission to do it.

AI could already click things. What changed?

This part is important.

Computer use did not start with Astra.

OpenAI launched Operator in January 2025. Operator could already look at webpages, click, type, scroll, and complete browser tasks. Those abilities were later built into ChatGPT agent.

So Astra did not invent AI that can use a computer.

What changed is how capable the model appears to be at this kind of work.

The 92.7% number needs some context

One of the Astra numbers you may see online is 92.7%.

That comes from a test called ScreenSpot-Pro.

Here is the simple version of what that test asks:

The AI gets a screenshot from professional software.

Then it has to locate the correct button, field, menu, icon, or other item on that screen.

This is called GUI grounding.

Basically:

Can the AI look at a complicated screen and correctly point to the thing you asked for?

Astra scored 92.7%.

OpenAI's previous GPT-5.6 Sol model scored 76.9%.

That is impressive.

But it does NOT mean Astra successfully completes 92.7% of software tasks.

ScreenSpot-Pro uses screenshots. It tests whether the model can locate the right place on the screen. It does not test whether Astra can click through an entire process from beginning to end.

That distinction matters.

So how good is Astra at completing whole tasks?

For that, another test is more useful.

It is called AutomationBench.

AutomationBench tests longer professional workflows.

The AI may need to understand a task, use different systems, make decisions, and complete several steps correctly.

Astra scored 41.4%.

GPT-5.6 Sol scored 18.1%.

Claude Fable 5.1 scored 31.4%.

That improvement is a big deal.

But there is another way to read that number.

Astra did not fully complete 58.6% of the workflows under the benchmark's scoring rules.

So this is not:

"AI can now do your entire job correctly."

It is:

"AI is getting much better at doing real work on a computer, and it is finally getting good enough that I want to start testing where it helps me."

So what would I actually test as an instructional designer?

This is where Astra gets interesting.

These are not promises that Astra will work perfectly inside every LMS, authoring tool, or company system.

Different systems have different access rules, security restrictions, interfaces, and permissions.

These are the workflows I would personally test because they line up with the things Astra appears to be especially good at.

1. Check an old software job aid against the current system

This might be my first experiment.

Imagine you built a job aid six months ago.

It says:

1. Click Settings.
2. Choose User Management.
3. Select Add User.
4. Enter the employee information.
5. Click Save.

Then somebody updates the software.

The button moves.

A label changes.

There is a new step.

Your job aid is now wrong.

This is exactly the kind of problem where Astra's screen understanding could become useful.

If Astra has approved access to that environment, I would test whether it can work through the current process while using the old instructions.

Then I would ask:

• Which steps still match?
• Which labels changed?
• Where does the old job aid tell me to click something that is no longer there?
• Did the process gain another step?

I would still verify every change myself.

But if Astra can give me a strong first pass, that could save a lot of time.

2. Test a learning experience like a learner

This is another one I would test quickly.

Let's say you built a web-based learning game or simulation.

Normally you need someone to click through it.

Try the wrong answer.

Go backward.

Click buttons in weird orders.

Check whether the score updates.

Make sure the completion screen appears.

Find broken navigation.

Astra's combination of computer use and software abilities makes this kind of QA interesting.

I might give it a defined test like:

• Complete the activity successfully.
• Then run it again and intentionally choose every wrong answer.
• Try every navigation button.
• Write down anything that does not work as expected.

The important part is giving it clear test criteria.

I would not simply say:

"Make sure my course works."

I would tell it exactly what I want tested and then verify the results myself.

3. Compare instructions with what actually happens on screen

This is slightly different from asking AI to write a job aid.

Almost any good AI model can write instructions.

The Astra-specific opportunity is giving the AI access to the real workflow first.

For example:

Here is our current SOP. Work through this process in the approved training environment. Tell me where the instructions stop matching what you actually see.

That is interesting because Astra can potentially use both pieces at once:

• What the document says should happen.
• And what the software actually shows.

For software training, that could be extremely useful.

4. Test a process that crosses several tools

This may eventually be one of the biggest opportunities.

A lot of our work is not difficult because any single step is hard.

It is difficult because we have to jump between places.

Check the LMS.

Open the attendance tracker.

Look at the roster.

Check another file.

Update something.

Then send a message.

OpenAI describes Astra as being built for difficult end-to-end work across computer use, coding, research, documents, and other professional tasks.

So I might eventually test something like:

• Find the learners who have not completed Module 3.
• Compare them with yesterday's attendance.
• Update the tracking file.
• Then prepare a list of the people who need follow-up.

That is where Astra starts to feel different from the AI most of us first learned to use.

But again, I would test this in a safe environment before trusting it with anything important.

5. Build something, then actually test it

Astra is also very strong at software engineering.

That matters if you are an instructional designer who is starting to build your own learning games, simulations, websites, or tools.

Lots of AI models can help write code.

That alone is not the interesting part.

The more interesting workflow is:

• Build this.
• Run it.
• Use it.
• See what breaks.
• Fix it.
• Run it again.

For example:

Build this small learning game. Then play through each path. Check every button. Find any errors. Fix the errors. Then test the game again.

That kind of loop is much closer to Astra's strength in end-to-end computer work than simply asking:

"Write code for a learning game."

6. Troubleshoot something it can see

This one is simple but useful.

Have you ever tried explaining a software problem to AI like this?

"There is a little menu on the right. I clicked the second thing underneath the blue box. Then another window opened, but I can't find the thing I'm supposed to click."

That can get painful fast.

If Astra has access to the interface, the model can work from what is actually on the screen.

That could make it useful for troubleshooting software, testing interfaces, or helping someone work through an unfamiliar system.

Again, I would treat this as something to test, not something Astra is guaranteed to do perfectly in every tool.

What about documents and presentations?

Astra is also designed to create documents, presentations, research, and other professional work.

OpenAI specifically lists document creation as one of the model's strengths. It also promotes Astra for polished presentations and professional-quality work.

So yes, an instructional designer could absolutely use Astra to help create:

• training decks
• facilitator guides
• reports
• analysis
• and other learning materials

I just would not call that the biggest reason to care about Astra.

We already have very capable AI tools for creating content.

What interests me more is what happens when content creation gets combined with computer use.

For example:

Review the actual process. Find where the training is wrong. Correct the source document. Then create the updated training deck.

That is a much more interesting workflow.

What about huge amounts of information?

Astra can also handle a huge amount of information at once.

Its API supports a context window of 1.05 million tokens.

You do not need to know what a token is.

The beginner-friendly version is:

Astra can keep a very large amount of text in front of it while it works.

That could be useful if you are dealing with a big collection of:

• policies
• SOPs
• course materials
• SME notes
• assessments
• and reference documents

But again, reading a lot of information is not the main thing that makes Astra interesting to me.

The bigger opportunity is:

What can it do after it reads that information?

The easiest way I know to explain Astra

A lot of the AI most of us started with was good at:

"Tell me how to do this."

Astra is part of the shift toward:

"Go do this."

That is a very different relationship with AI.

And it changes the kinds of prompts that become interesting.

Instead of:

"Write me a job aid."

Try:

"Use this job aid to complete the process. Tell me where the instructions no longer match the software."

Instead of:

"Review my learning game."

Try:

"Play through these five paths. Test every button. Tell me exactly where the experience breaks."

Instead of:

"Help me update my tracker."

Try:

"Compare these records with the source system and identify what needs to be updated."

Those are jobs.

Not questions.

What I would not do yet

• I would not give Astra broad access to an important system and walk away.
• I would not assume a completed task was completed correctly.
• I would not let it make high-impact changes without review.
• I would not assume it can use every LMS or every authoring tool.
• I would not put private company information into an environment my organization has not approved.
• And I would not confuse a great benchmark score with perfect real-world reliability.

OpenAI's own AutomationBench result gives us a pretty good reason not to do that.

41.4% is exciting.

It is also 41.4%.

How I would test Astra

I would keep the experiment very small.

Choose one real task.

Define exactly what success looks like before you start.

For example:

There are 20 steps in this job aid. Astra needs to identify every step that no longer matches the software.

Then run it.

Check every result yourself.

Now you have a useful number.

Not:

"Astra scored 92.7% on some benchmark."

But:

"Astra correctly identified 17 of the 18 outdated steps in my actual job aid and saved me an hour."

That is the number I care about.

Why instructional designers should pay attention

I do not think Astra matters because it can write training.

AI could already do that.

I think Astra matters because AI is becoming better at working inside the same digital environments where the work happens.

Looking.

Finding.

Testing.

Checking.

Navigating.

Building.

Running.

Fixing.

Moving between tools.

And continuing through a task.

It is still early.

It still makes mistakes.

It still needs access, tools, permissions, guardrails, and human verification.

But that is exactly why I want to experiment with it now.

Not because a benchmark says Astra is the smartest AI.

Because I want to know which pieces of my actual work I can hand it.

Do not ask it another question.

Give it a job.

Sources

1. OpenAI, GPT-6 Astra launch page, for the rollout date and the ScreenSpot-Pro and AutomationBench figures: openai.com/index/gpt-6-astra
2. OpenAI API documentation for GPT-6 Astra, for computer use, professional work, and the 1.05 million token context window: developers.openai.com
3. OpenAI, Computer-Using Agent, for Operator and what it could already do in January 2025: openai.com/index/computer-using-agent
4. ScreenSpot-Pro benchmark documentation, for what GUI grounding measures: github.com/likaixin2000/ScreenSpot-Pro-GUI-Grounding
5. Anthropic, Claude Fable 5.1 announcement, for the Claude Fable 5.1 AutomationBench figure: anthropic.com/claude-fable-and-mythos-5-1