Good morning.
GPT-6 Astra shipped on September 3, and it's the first model built to use a computer the way you do:
Clicking through your CRM, filling in the supplier portal that has no API, driving Power BI, updating the sheet that three people depend on. A chunk of the integration work you've been paying someone to wire together is now optional.
Today: where that pays and where it burns money, the brief that keeps it on task, nine prompts you can point at it this afternoon, and the benchmark number I'd stop repeating.
— Sam
IN TODAY’S ISSUE 🤖
What computer use replaces in your stack
Where to get Astra, and the rollout mess
When clicking beats an API call
The brief that keeps Astra on task
Nine copy-paste prompts, dashboards to landing pages
The 99.9% score that came back at 62.7%
What one Astra task costs to run
Why Astra needs its own logins
Which plays fit your business type
Where this leaves your automation spend
What Computer Use Replaces
Every month you sign into something that has no API, read a few numbers off the screen, type them into a sheet, and message someone about what changed. It might be a supplier account, a billing dashboard, a fulfillment partner, or an ad platform your reporting tool doesn't cover. You've looked at automating it at least once and worked out that the work cost more than the twenty minutes.
That job is the first thing to point Astra at, because it's the exact work that sat outside every automation tool you've ever paid for.
Greg Brockman put the case plainly at launch, and it's worth reading as an operator rather than as a developer:
"We've been bottlenecked over this gigantic era by people writing connectors and very painstakingly building these connections into all these tools that people can already use… \[Now\] an agent can instead zip through spreadsheets, fill out forms, \[and\] navigate across web pages." (VentureBeat)
The practical translation: the model treats the human interface of your software as its API. Every tool you use has a screen. Astra can read that screen, find the button, and press it.
Think about where your money currently goes to bridge that gap:
A Zapier or Make subscription, billed per task, that somebody set up and nobody has audited since.
An n8n instance running on a server one person in your business understands.
A VA who signs into four billing portals on the first of every month.
A developer's Google Sheets sync that breaks whenever the vendor renames a column.
Every one of those exists because two pieces of software refuse to talk to each other, and someone has to be paid to translate.
OpenAI's own numbers on this are narrow but real. On OSWorld 2.0, the standard computer-use benchmark, Astra scores 72.6% against GPT-5.6 Sol's 65.7% and Claude Opus 5's 70.2%, and OpenAI reports it finishing those tasks in about 47% less time per task under latency simulation (OpenAI).
The bigger jump sits on AutomationBench, which measures whether a multi-step workflow gets finished rather than whether a single click was correct:
Benchmark | GPT-6 Astra | GPT-5.6 Sol | Claude Fable 5.1 | Claude Opus 5 |
|---|---|---|---|---|
OSWorld 2.0 (computer use) | 72.6% | 65.7% | not published | 70.2% |
ScreenSpot-Pro (finding the right element) | 92.7% | 76.9% | not published | not published |
AutomationBench (multi-step workflows) | 41.4% | 18.1% | 31.4% | 26.9% |
Terminal-Bench 4.0 | 57.9% | 37.3% | 55.8% | 52.6% |
Read AutomationBench twice. 41.4% is the number that decides whether Astra is useful to you, and it means Astra finishes fewer than half the multi-step workflows it's handed. That's more than double Sol, which is why the launch coverage reads the way it does.
It's also a coin flip you lose more often than you win, so plan a review step into everything you hand it. Anyone telling you to set this loose on your month-end close has not run it.
Where the gains show up outside OpenAI's own lab, they get smaller and more specific. Three customers put numbers to it in the follow-up post a week after launch (OpenAI):
Hebbia: decks that followed the brief 17% more faithfully than the next-best model, and sourced their claims to the right document 19% more often.
Box: 10% less likely to make a confidently incorrect assertion.
CodeRabbit: around 20% more bugs caught, and more than double the catch rate on pull requests.
Single-digit and low-double-digit improvements on work that already worked. That's the honest scale of what most of us will feel, and it's worth more than the headline benchmarks because somebody outside OpenAI measured it.
Where To Get Astra, And What It Costs
Astra reaches you through the subscription you already have, which is the part of this release that matters most to a business under $3M.
ChatGPT Plus at $20/month includes Astra. Same price you were paying in August, better model, and for most of this list that's the whole budget conversation.
ChatGPT Pro adds GPT-6 Astra Pro, a higher reasoning ceiling for the hardest jobs. Worth it if you're running long analytical work, hard to justify otherwise.
Business and Enterprise seats get Astra, but it's off by default and an admin has to switch it on per workspace. If you have a team and nobody can see it, that's a settings problem, not a rollout problem.
The API runs $10 per million input tokens and $50 per million output, with cached input at $1.00 and a Fast mode at exactly double both rates for up to double the speed (OpenAI). It's also on Azure and AWS Bedrock, where Foundry's long-context tier runs $20/$75.
The API price only matters if you're building Astra into something you sell. For running your own business, the subscription covers it, and the next section on cost explains why the per-token number misleads anyway.
One thing the launch coverage skipped: the rollout was a mess, and Sam Altman apologized for it on September 7. Plus and Business users got access last rather than first, API developers were locked out for days, and an OpenAI engineer put it down to coordination rather than capacity (CSO Online).
So if you read the launch post, went looking, and couldn't find it, you weren't doing it wrong. Check again this week.
When Clicking Beats An API Call
Computer use is slower and more expensive than a direct integration, every time. Astra has to load the page, look at it, decide where to click, click, and wait.
A webhook does the same job in 200 milliseconds for a fraction of a cent. So the decision rule writes itself: use computer use where no good connection exists, and use the connection everywhere else.
Five places where clicking wins:
Tools with no public API. Supplier portals, industry-specific software, your accountant's document system, the platform your biggest client insists on. This is the category Zapier could never reach, and it's where the whole story lives.
Multi-source reporting. Pulling GA4, Search Console, your ad manager, and your ESP into one Monday report means operating four interfaces in sequence. Aggregator tools that do this start around $200 a month.
Template-faithful artifacts. OpenAI calls Astra its "best model for adhering to existing templates," and the practical version is a proposal or a deck that comes out matching your brand file without somebody fixing the fonts afterwards.
Clicking through your own product. Claire Vo, who runs ChatPRD, pointed Astra at a preview branch and it spent one hour and forty-five minutes clicking through the app, sending chats, refreshing, and reading the developer console, and it found issues her team had missed (ChatPRD). An hour and three quarters of patient clicking is a thing humans are bad at and a machine is indifferent to.
One-off jobs. Anything you'll do twice is not worth an integration. Anything you'll do two hundred times is.
Four places where it loses:
Anything with a clean API you already pay for. Building a computer-use routine to do what a native integration does is slower, pricier, and more fragile.
High-volume repetitive work. Fifty records is fine. Five thousand is a script.
Cyber-adjacent work. Astra meets the Critical threshold under OpenAI's Preparedness Framework, so it refuses offensive security tasks and its safety monitoring can pause legitimate defensive work until a human reviews. If your workflow touches security tooling, design for the interruption.
Anything you want to set and forget. See the previous point, and see the 41.4%.
The cheapest way to find your own line is to run one job and time the cleanup. Take something you do weekly, hand it over once with a careful brief, and clock how long you spend reviewing and correcting what comes back. If the review takes longer than doing the job yourself did, you've found a job Astra shouldn't have, and you know it after one run instead of after a month of half-trusting it.
The Brief That Keeps Astra On Task
Most of the disappointment with computer use comes from briefing it like a chat model. A chat model produces text and you judge the text. Astra produces actions in your live accounts, which means the brief has to carry the things a new hire would ask before touching anything.
Five parts, and the last two are the ones people leave out:
The destination. Name the tool, the URL, and the exact place the work ends up. "Update the CRM" is not a brief. "In HubSpot, on the Deals board, in the Q4 Pipeline view" is.
The source. Where the inputs live, and which one wins when two disagree.
The format. Point at a file, a template, or an existing example and tell it to match. This is where Astra's template adherence pays, and it only pays if you give it the template.
The stopping condition. What "done" looks like, and what to do when it hits something the brief doesn't cover. Without this it improvises, and improvisation inside your billing portal is how you find out what a safety pause feels like.
The approval gate. Anything that sends externally, spends money, or deletes something stops and waits. Write the boundary into the brief rather than assuming the model has your judgment about what's reversible.
Here's the skeleton I'd paste at the top of any computer-use job:
Work in [TOOL] at [URL]. I've already signed in.
Source: [where the inputs are]. When [source A] and [source B] disagree, use [A].
Output: [what you're producing], matching the format in [file or existing example].
Done means: [the specific end state].
Stop and ask me before: sending any message outside the company, spending money, deleting anything, or changing settings that affect other users. Also stop if you hit something this brief doesn't cover rather than guessing.
Log every action you take in a running list so I can read what happened afterwards.That last line matters more than it looks. Astra works for minutes or hours at a time and you will not be watching, so the log is the only record of what it did while you were on a call.
Nine Prompts To Run This Afternoon
Each of these assumes you're signed into the tool already and that you've pasted the skeleton above. The nine are ordered roughly by how fast they pay.
1. The Monday Report From Four Dashboards
The reporting job that eats a morning, replaced by one run.
Open, in this order: Google Analytics 4, Google Search Console, [your ad platform], and [your email platform]. For the last 7 days against the 7 days before that, pull sessions, conversions and conversion rate, top 10 landing pages by sessions, top 10 queries by clicks, ad spend and cost per result by campaign, and email sends, open rate and click rate.
Write it into [template file or doc] using the same section order and table format that document already uses. Flag anything that moved more than 20% either way, and under each flag write one sentence on the likeliest cause based on what you can see in the other three dashboards.Why it's built this way: the value is the cross-reference, which needs one thing looking at all four screens in one sitting. Any export hands you the numbers. Naming the order stops it wandering off mid-run.
2. The Checkout Walk-Through
For anyone with a cart, a booking page, or a paid funnel.
Go to [URL] and buy [product] as a first-time customer would. Walk every step: product page, variant selection, add to cart, cart, checkout, payment form, confirmation. Stop before submitting payment.
At each step, record: what loaded, how long it took, anything visually broken, any field that rejected valid input, and anything confusing to someone who has never seen this site. Then do it again on a phone-sized window.
Return a numbered list of problems ranked by how many buyers each would lose.Why it's built this way: you can't see your own checkout any more. The "first-time customer" framing and the mobile pass are what surface the things you've stopped noticing. Run it before any launch.
3. The Live CRM Cleanup
Not a CSV you have to re-import. The records, in the system.
In [CRM], open the [view or list]. For every record: fill any blank company, role or source field using the contact's LinkedIn or company site, correct obvious formatting problems in names and companies, and tag anything with no activity in 60 days as Stale.
Do not merge or delete anything. Where two records look like duplicates, tag both Possible-Duplicate and add the other record's URL to the notes.
When you're done, give me a summary: records touched, fields filled, duplicates flagged, and any record you couldn't resolve.Why it's built this way: the no-delete, no-merge boundary is what makes this safe to run unattended. Every destructive action becomes a tag you review in ten minutes.
4. The Pre-Call Brief
Research [company] and [person] and write me a one-page brief in [template file].
Pull: what the company sells and to whom, headcount and any recent change, funding or ownership news in the last 12 months, anything they've published or posted in the last 90 days, and the three things on their site that suggest where they're investing.
Then check our own records: search [CRM] and my email for every previous touch with this company and summarise what was said and when.
End with three questions I should ask that I couldn't have asked without this research. If a section is thin, say so rather than filling it.Why it's built this way: the last sentence is the whole prompt. Astra's hallucination rate on OpenAI's internal benchmark is 4.2% against Sol's 12.2%, which is better and is not zero, and a brief that pads a thin section is worse than no brief when you're in the room.
5. The Competitor Price Watch
Visit the pricing page of each of these: [list of 5 URLs]. For each one, record every tier name, price, billing period, and the features listed under each tier. Screenshot each page.
Compare against [last week's file]. Write me only what changed: new tiers, removed tiers, price moves, feature moves between tiers, and any change to the free trial or guarantee. If nothing changed on a page, say "no change" and move on.
Save the new readings to [this week's file] so next week has something to compare.Why it's built this way: the "only what changed" instruction and the saved state file are what turn this from a report you stop reading into an alert you act on. Without a state file it re-reports the same thing every week and you tune it out by the third run.
6. The Proposal In Your Template
Build a proposal for [client/prospect] using [template file] exactly: same sections, same order, same fonts, same table styles, same cover.
Source the content from: [the discovery notes], [the pricing sheet], and [the two previous proposals that closed].
Scope is [scope]. Price is [price]. Where the template has a section I haven't given you material for, leave the section heading and write TO WRITE underneath it rather than inventing content.
Export as [format] and save to [location]. Don't send it anywhere.Why it's built this way: TO WRITE beats a plausible paragraph you have to catch. Template adherence is the one place Astra's benchmark lead translates directly into time you get back, because "fix the fonts" is a real recurring half hour.
7. The Subscription Audit
Sign into each of these billing portals: [list]. For each account, record every active subscription, the plan, the monthly or annual cost, the renewal date, the number of seats, and the last login date if the portal shows it.
Put it all in one table sorted by annual cost, highest first. In a second table, list anything that looks unused: seats nobody has logged into in 60 days, plans above the usage shown, and anything renewing in the next 30 days.
Cancel nothing. Change nothing.Why it's built this way: this is the clearest job for Astra, because none of these portals has an API and the job is an hour of tedious clicking you've been putting off since spring. Run it once a quarter.
8. The AI Answer Check
Open ChatGPT, Perplexity and Google's AI results in separate tabs. Ask each one these questions as a buyer would: [list of 10-15 buying-intent questions about your category, not your brand].
For each question and each engine, record: which companies were named, in what order, what was said about each, and whether we appeared at all. Note the source each engine cited.
Compare against [last month's file] and tell me where we moved up, moved down, or dropped out, and which competitor took the slot.Why it's built this way: the questions have to be about the category rather than about you, because that's how a buyer who doesn't know you yet would ask. Astra visiting the engines directly is a different thing from a monitoring tool's index, and it's closer to what a buyer sees. If you want the build behind this, it's in Become The Source All LLMs Quote.
9. The Landing Page From One Screenshot
Nick Babich at UX Planet published the method that fixes most of what's wrong with AI-generated pages, and the first step is the whole trick (UX Planet).
Here is one screenshot: [attach a single page you admire]. Use it as the reference for composition, spacing, density and type hierarchy only. Don't copy its content, its colors, or its brand.
Our typography is [X], our colors are [X], and the motion should feel [X].
Build the page section by section, and show me each section before moving to the next. Section 1 is the hero: headline [X], subhead [X], one CTA reading [X].Why it's built this way: one anchor screenshot beats a mood board of six. Babich's finding is that a single reference for composition produces measurably better output than either a collection of references or a written description, and the section-by-section instruction stops you getting a finished page you then have to argue with.
The 99.9% Score That Came Back At 62.7%
If you're going to repeat one number from this launch in front of someone whose opinion you care about, don't make it the ARC-AGI-3 score.
OpenAI's launch table puts Astra at 99.9% on ARC-AGI-3, against 17.8% for Sol and 30.2% for Claude Opus 5. That number is real, and it's conditional.
The ARC Prize Foundation ran Astra themselves and published both results (ARC Prize):
Standard harness: 62.7%, at a cost of roughly $26,000.
Provider adapter harness: 99.9%, at roughly $19,000. This one preserves the model's reasoning state between requests and compacts longer conversations.
Same model, same benchmark, thirty-seven points apart. The gap is the scaffolding around the model rather than the model.
That matters to you for one reason: The scaffolding is what you're buying. A benchmark number that only appears with a particular harness tells you the system is strong and tells you nothing about how the model behaves inside yours.
It's the same lesson that keeps showing up: the model is one component, and context around it decides what you get.
Three more corrections to have ready before someone hands you a slide with these numbers on it:
Astra is not top of the composite tables. On Artificial Analysis's Intelligence Index v4.1.1, OpenAI's own published comparison, Astra scores 61.26 against Claude Fable 5.1 at 65.76, Claude Opus 5 at 63.15, and Claude Fable 5 at 62.16. Astra sits fourth of six on the index OpenAI chose to print. Its lead is in computer use and in math and science, and it's roughly level with Sol on general reasoning.
GDPval is missing. OpenAI's own real-world-work benchmark from 2025 doesn't appear anywhere in the launch materials, which is a conspicuous absence next to "welcome to the AGI era" (VentureBeat).
The safety improvement is real, and it's a range. Astra produces unintended outcomes in 2.4% of OpenAI's computer-use safety tests against Sol's 22.0%, and it went beyond its authorized scope 0% of the time against Sol's 48% (OpenAI). With safeguards already on, though, the improvement narrows to around 58%. Both numbers are true and the second is the one that describes your setup.
The reason to hold all this straight isn't pedantry. Publish a competitor comparison, a pricing analysis, or a recommendation to a customer built on a number that doesn't survive a reader checking it, and you spend credibility you can't buy back.
Box's evaluation found Astra doing the opposite. On a task where a required figure was missing from the source documents, Astra flagged the gap, labeled its own number a proxy, and caught a growth claim that didn't match the data underneath it. Sol reported the proxy as the real thing (Box). For a business that publishes, that behavior is worth more than any benchmark row in this issue.
What One Astra Task Costs To Run
The $10/$50 per million tokens looks expensive next to the competition, and per-token pricing is the wrong unit for a model that reasons before it answers. The unit you want is cost per finished task.
Artificial Analysis measured Astra using about 27,000 output tokens per task at maximum effort, against Claude Fable 5.1's 78,000, with full index runs costing between $0.82 at low effort and $3.26 at maximum (Artificial Analysis).
Roughly a third of the output tokens at twice the token price works out close to level. That's why OpenAI's cost-efficiency-frontier line holds up better than the rate card suggests, and it's the reason to price this work per finished task rather than per million tokens.
For running your own business, the practical version is shorter. Your $20 Plus subscription covers it. Three notes on the edges:
The API matters when you're building Astra into something you sell, and not when you're running your own operation on it.
Fast mode at double the rate is worth it for work a customer is sitting there waiting on, and wasted on anything that runs overnight.
Before you add another $200-a-month tool to bridge two systems, spend an afternoon on prompts 1 and 7 above and see what's left to bridge.
Give Astra Its Own Logins
Astra works by signing into your accounts, which changes what a mistake costs. Four things to set up before you hand it anything that matters, and none of them takes longer than the coffee:
Its own credentials, not yours. Make a separate user in your CRM, your ad manager, and anywhere else it'll work, scoped to the minimum permissions the job needs. When something goes wrong you want to know which account did it, and you want to be able to switch that account off without locking yourself out.
Approval before anything leaves the building. Email, ads, payments, published content. This lives in the brief, and it also lives in Astra's own confirmation policies if you're on a Business or Enterprise workspace.
The admin controls, if you have them. OpenAI shipped workspace controls with the September 10 release: restrict Astra to approved websites and desktop apps, manage what it can upload and download, set confirmation policies before consequential actions, and turn on automated review of unsafe tool calls. Off by default, worth twenty minutes.
A log you'll read. The running-list line in the brief skeleton, plus a habit of reading it the first ten times you run a job. You're calibrating how much rope to give it, and you can't calibrate on a summary.
The Plays By Business Type
Agencies and consultancies. Your highest-value use is the reporting stack, because multi-client reporting is the work that scales worst and clients judge you on. Prompt 1, run per client, in each client's own template. The second is the pre-call brief, which turns research from a thing you skip when the week is full into a thing that happens whether or not you have time. Start with prompt 1, one run per client, in their template.
Ecommerce. Prompt 2 before every launch and every seasonal push, and prompt 5 on your five closest competitors weekly. Then the one that pays all year and never gets scheduled: a weekly pass over your product pages checking that variants, stock states, shipping copy and promotion codes say what you think they say. Start with prompt 2, before your next launch.
SaaS and software. The QA pattern from Claire Vo's run is the one to copy, because an hour and forty-five minutes of patient clicking through a preview branch is cheap and it catches the class of bug your team stops seeing. Pair it with prompt 3 on the CRM. Start with prompt 2 on a preview branch and give it an hour.
Experts, consultants and course businesses. Prompt 6 for proposals, prompt 8 for whether the engines recommend you, and prompt 9 for the offer page you've been meaning to rebuild since July. If you sell your judgment, the wins here are in the artifacts around the judgment rather than in the judgment itself. Start with prompt 6 on your next proposal.
Everyone with a team. The subscription audit is the most reliably profitable hour in this issue and nobody ever schedules it. Start with prompt 7, this quarter.
What Astra Doesn't Change
The bottleneck in your business was never the clicking.
A model that operates your software takes the mechanical work off your plate. What's left is what was always the real constraint:
Knowing which report matters this week.
Knowing which deal is dead and which one is only slow.
Knowing what your offer should cost.
Knowing whether the thing you're about to publish is true.
Astra finishes 41.4% of multi-step workflows unaided and flags its own gaps well, and that combination describes a capable assistant who needs a brief and a review. Which is roughly what you'd say about a good hire in month two.
So the question this release puts to you is which of your judgment calls you need to keep, and how much of the work around them you're still doing by hand out of habit. Everyone reading this has a list of jobs they do personally because handing them over was more trouble than doing them. That list got shorter on September 3.
So go and find one item on that list. The best first candidate has three marks: you do the job yourself, it runs on a schedule, and nothing it touches is irreversible. That describes a weekly numbers pull, a monthly reconciliation, a pre-call brief, or a pass over your own checkout.
Start there rather than with the hardest thing you own, because the first job you hand over is what teaches you how much to trust it with the second.
Last Byte
The number I find really interesting is Claire Vo's hour and forty-five minutes. That's an hour and forty-five minutes of patient clicking nobody would have done carefully, on a Tuesday, for free, while she got on with something else.
Most of what Astra changes for a business your size looks like that:
Unglamorous work that was always worth doing and never worth your time.
Which is what makes a new offer possible. Every one of us has declined work, or never built a service, because our cost to deliver it was too high.
When the cost to deliver drops like it has now, the list of offers you can profitably make gets longer.
In Cortex, I share the formulas and strategies that help busy online business owners implement AI and Agents inside their businesses, in just minutes or hours instead of days or weeks.
Talk soon,
Sam Woods
The Editor
