Astra can use a computer. What does that change for design?

OpenAI released GPT-6 Astra on the 3rd of September, and I’ve been thinking about it more than I expected to. What OpenAI leads with is that the model can use a computer. It opens apps, fills in forms, clicks through web pages, works in spreadsheets. Basically the things we do all day, done by the model on its own.

I started writing this before I had access. OpenAI said Plus and Pro users would get it “over the coming days”, and mine was one of the accounts still waiting. Then it showed up halfway through the draft, so this post changed shape. The first part is what I did with it on day one. The rest is what I think it means for the work, and I’d still like to hear from you if you see it differently.

What I did with it first

Not the design tests I had planned. The first thing I did was point it at my own website.

Some context. I’m a designer who builds his own site, and I’m not a full developer. I know enough to get things working and not always enough to know what I got wrong. So my honest question to Astra was: go through this and tell me what I did badly.

It found things. The biggest problems were in the JSON files the site relies on, and there were a few security issues I had no idea were there. I’d asked other models to check the same code before, more than once, and they came back with nothing. No improvements, no vulnerabilities, all fine. Astra found them and fixed them, and the whole thing took a few minutes. I’m still a bit annoyed about how long those had been sitting there.

Then I asked it to make the site faster, especially on mobile. It did, and the speed score went up again, which I didn’t think had much room left.

My impression after a day: it’s maybe a little slower than what I was using before. But the quality of what comes back is on another level, and it feels more natural to work with, like talking to someone who actually read the code.

What actually came out

The number OpenAI keeps pointing to is from OSWorld 2.0, a benchmark where the model has to finish real tasks on a real desktop. Astra gets through 72.6 percent of them and takes about 40 minutes per task. The previous model, GPT-5.6 Sol, managed 65.7 percent and needed 75 minutes. So it’s not instant, and that matches my experience, but it gets more done in about half the time.

A couple of other things caught my eye. The context window is a million tokens, and the model keeps notes across windows, so a long job doesn’t lose the thread halfway. And the way it reasons is new. OpenAI calls it recurrent depth: the model loops over a problem internally instead of writing every step out. Faster and cheaper, but harder to look into, and a few safety researchers have already said they’re uneasy about that.

For developers it costs 10 dollars per million input tokens and 50 per million output. There’s no free tier. If you let it work on something for forty minutes, that bill adds up.

One thing I’d take with a grain of salt: the 99.9 percent on ARC-AGI-3 you see in the headlines comes from OpenAI’s own setup. On the standard test it scores 62.7. Still a big jump, just not the number in the headline.

And there’s one line from OpenAI’s own system card that I can’t stop thinking about. In their adversarial tests the model sometimes pulled out credentials, changed safeguards and got around access controls it wasn’t supposed to touch. They describe it as a risk they’re managing. I read it as something we’ll have to design for, and I’ll come back to that below.

The part I keep thinking about

For a few years “AI in design” meant text and images coming out of a box. Handy, sometimes, but separate from the products we actually ship. That’s over now. The model works inside the same interfaces we design for people. Same buttons, same labels, same forms.

So every interface we make has a second user now. And this one shows up with zero context. It has never used your app, it doesn’t know what your custom icon means, it hasn’t seen your onboarding, and it can’t lean over and ask a colleague. It reads what’s on the screen and takes it literally.

To be honest, I find this more reassuring than scary. The interfaces that will hold up are the ones that were already good. Labels that say what the field is for. Buttons that say what they do instead of “Continue”. States you can read without colour. Error messages that tell you what happened and what to do next. I’ve spent thirteen years pushing for exactly this in bank and marketplace products, usually against someone who thought it was a nice-to-have. Now there’s a user who simply fails if it’s not there.

The other side is what happens to the tricks. The button that guilts you into staying, the pre-ticked box, the cancel flow hidden four screens deep. Those work on a tired person at eleven at night. Do they work on a model reading the page on that person’s behalf? I don’t think so. It either gets stuck, or it tells the person plainly: the site tried to add insurance, I said no. I’m curious how quickly companies notice that.

If you want a short version to bring to your team: the accessibility work is the agent work. If you’ve done the semantic structure, the labels, the focus order and the honest error messages, you’ve already done most of it.

What about Figma?

This is the part everyone asks about, me included, and I haven’t got to it yet. My first day went into the website. But here’s where I stand before I try.

The most concrete thing I’ve seen so far is Claire Vo’s review from launch day. She had Astra put together a finished YouTube thumbnail in Figma from generated assets while her designer was away. Her take was that she’d polish it a bit, but for a fully automated result it worked. OpenAI’s developer team also says the model has “stronger visual judgment” for front-end work and can fix layout, type and spacing from a screenshot and a reference.

I believe the first one. The second one I want to test myself, because “visual judgment” is exactly the thing I’d expect a model to fake well. My guess is that it’ll be really useful for the production part, once the direction is agreed: building all the states and sizes of a component, renaming layers, resizing frames, exporting, clicking through a live flow and telling me where it dead-ends, reading every label in a product and flagging the vague ones. That’s real work and it eats afternoons.

What it won’t do is the part before that. I wrote earlier this year that our expensive mistakes happen before anyone opens a design tool. Solving a problem only one loud stakeholder had. Building around a process that changes next quarter. Astra makes everything after the decision faster. It doesn’t make the decision, and it can’t tell you which constraint is a habit nobody questioned and which one is law. Someone still has to sit in the room and ask annoying questions for a week. I’m fine with that being me.

Two things I’d keep in mind. Forty minutes per task means this is a colleague you brief and check on later, not someone typing next to you. And nobody knows the failure rate on real work yet. My website is one data point. It’s a good one, but it’s one.

If you lead a design team

If production gets cheap, a few things that were on the “someday” list become urgent. This is how I’d think about it, and I’d like to hear if you see it differently.

Hire and grow people for judgment. Fewer hands drawing production screens, more people who can write a brief the model can actually execute and then judge what comes back. The brief becomes a design deliverable in its own right. Writing was always a big part of the job. Now it’s the part that produces the screens.

Stop counting screens, if you still do. It was never a good measure, and now it measures nothing.

Treat your design system as the guardrail. A model producing UI at speed will produce whatever you let it. A system where someone actually decides what can change, and how, is what keeps that output correct and on brand. I’ve written before that a design system is a governance problem. It just became the governance layer for a much faster producer.

Treat agent safety as product design. That system-card line again. When a model acts for a user inside your product, you need a consent step before anything consequential, a visible record of what it did, and a way back. That used to be a safety team’s problem. Now it’s a screen, and someone on your team has to design it.

And ask where it runs. Which model, hosted where, seeing what. For those of us in Europe that’s more than paperwork: it decides what you can even put in front of the model. I’d want that question in the design lead’s hands, not only in legal’s.

What I’ll try next

The website was the warm-up. These are the design tests, and I’m writing them down now so I can’t change them later without saying so.

1. A rough Figma file, a written spec, and a request for every state and size of one component. I’ll time it against what a designer does in an hour and count the corrections.
2. A live flow I know well, and the task “complete this as a first-time user, then tell me where you got stuck”. A usability test with the most literal participant I’ve ever had.
3. One screenshot, our design tokens, and “fix the spacing and type”. That’s the visual judgment test.
4. All the labels and error messages in a product, and “which of these don’t say what happens next”.
5. A research folder, and “write the decision memo I would write”. I want to see what it misses, because that’s the part I’d keep doing myself.

I’ll write each one up here, including the ones that go badly.

Let’s compare notes

I don’t know yet whether Astra is the step change the launch-week reviews say it is. One day and one website is not enough to say. What I do believe is smaller and more useful: the case for clear, honest, readable interfaces just got a user that reads everything and forgives nothing. For the way I already like to work, that’s good news.

If you’ve tried it on something real, tell me what happened. I’ll update this post as I get through the list.