Working with GPT-6 Astra: The Operator Guide

GPT-6 Astra is the best computer-use model anyone has shipped, it costs 2.5x the model it replaces, and on independent reasoning tests it is flat. All three are true. This guide is about what to do with that.

It is written for the person who has to decide what runs where on Monday, not for the timeline argument about whether this is AGI.

For completeness, the other execution numbers: OSWorld 2.0 offline went from 65.7% on Sol to 72.6% on Astra, with Claude Opus 5 at 70.2% in between, and ExploitBench went from 78.5% to 100%. The OSWorld gain is real but modest; the ARC-AGI-3 jump is the one with a factor in front of it.

1. What you are actually buying

Strip the launch language and Astra is one capability sold hard: it can drive a computer for hours without losing the thread. Everything else in the announcement is downstream of that.

The pricing is $10 per million input tokens and $50 per million output. Two comparisons matter and most coverage only made the first:

Against GPT-5.6 Sol, it is 2.5x. That is the number your CFO will ask about, and the capability gain is real but not obviously 2.5x real for general work.

Against Claude Fable, it is identical. That is the number that should drive your decisions. At the same price you are choosing between a model that is ahead on operating software and one that is ahead on reasoning quality. Price has stopped being the tiebreaker, which means task shape is the only tiebreaker left.

Budget for two things that are not in the headline rate. Search and computer-use tool calls bill per call on top of tokens. And long agentic runs are exactly the workload that generates the most tokens, so the bill scales with the capability you bought it for.

2. The 37-point lesson, and why it is the most useful thing in the launch

On ARC-AGI-3, Astra scored 99.9% under OpenAI's own Provider Adapter harness and 62.7% under ARC Prize's standard harness. Same model, same tasks. The difference is that the Provider Adapter preserves opaque reasoning state between requests and compacts long contexts, so the model reuses prior work instead of rebuilding it.

The cost detail is the part to internalise: the run that scored 37 points higher was also 3.66x faster, used 49% fewer tokens, and cost $7,281 less. Better scaffolding was not a tax on performance. It was the performance.

Take the operator lesson rather than the AGI argument. A frontier lab found 37 points of capability by changing what the model carries between calls. Nobody has done that work on your workflows. Whatever you are running today is on the equivalent of the standard harness, and the gap between your current results and your achievable results is probably larger than the gap between two model versions.

Concretely, the three things the Provider Adapter did are three things you can do:

Carry state between calls instead of restarting the context each time. Compact rather than truncate when the context fills, so earlier work survives in summary instead of falling off the end. Let the model reuse its own prior reasoning rather than forcing it to re-derive. That is not exotic infrastructure. It is a week of plumbing on most stacks.

3. Route to it, route past it

The routing rule follows straight from the profile. Send Astra the work where the task is operating something over time. Send reasoning-dense work elsewhere, because at the same price you can currently get better judgment.

4. Computer use is for QA, not building

The single best piece of operating guidance from launch week came from Claire Vo, who used Astra on real production work and landed on a rule.

The logic holds up on inspection. Building through a UI is the slowest possible way to build, because the API underneath is faster, cheaper and more reliable. But QA through a UI is the only honest way to QA, because the UI is what your customer touches, and a model clicking through it at 3am finds the things your test suite was never pointed at.

So the highest-value first deployment is not "let it build the feature." It is "let it use the product the way a customer would, every night, and tell you what broke." That work has ground truth, a clear owner, and a baseline you already measure.

Vo's other observation is the one with strategic teeth, and it cuts against the direction most AI architecture writing has been running: UI is back. If agents operate software through its interface, then the interface is an agent surface, not a legacy human affordance to be deleted. That is worth sitting with if you had concluded that the API is the only thing that matters. Both can be true: the record layer matters more, and the screens just became machine-readable.

5. The knowledge-base pattern

The most transferable demo of the week was not a coding benchmark. Ethan Mollick pointed Astra at tens of thousands of his own emails, writings and calendar entries and had it assemble a personal knowledge base of research, contacts, ideas, relationships and tasks.

That is a company-shaped job wearing a personal disguise. Every organisation has a decade of decisions sitting in inboxes, documents and calendars that nobody can query, and until now assembling it was a project nobody would fund. Long-horizon computer use changes the arithmetic, because the model can grind through the corpus for hours without supervision and the cost is tokens rather than a team.

If you do this, do it on a copy, scope credentials to read-only, and pick a corpus with a clear boundary. The failure mode is not a bad summary. It is a model with live credentials to everything because it was easier than scoping.

6. What actually goes wrong

It overcomplicates. This is the consistent complaint from the people who liked it most. Dan Shipper's read is that Fable still has better instincts for building a product, and the failure mode is not wrong output, it is elaborate output. Watch for this on anything where a simple answer was correct.

The bill scales with the thing you bought. Hours-long autonomous runs plus per-call tool billing is a combination that surprises people in month two, not week one. Set a budget per workflow before the first unattended run, not after.

The headline number is not your number. OpenAI's best benchmark result came from OpenAI's own harness. Your results will come from your harness. Assume the neutral figure is the honest starting point and that the gap is yours to close.

Offensive security work is gated. Astra supports defensive work, secure code review and patching, and refuses advanced offensive tasks such as writing proof-of-concept exploits. If your security team was planning red-team automation, plan around this.

7. What to do Monday

Do not switch your default model. Add Astra as a route, not a replacement. The independent index says your general reasoning gets no better and your bill gets 2.5x worse if you move everything.

Pick one long-horizon job and run it overnight. Nightly QA against your real UI is the highest-signal first test, because you will know by morning whether it found something your tests missed. That is a falsifiable pilot, which is rarer than it should be.

Audit what your agents carry between calls. This is the 37-point question applied to your own stack. Are you restarting context every call? Truncating instead of compacting? Making the model re-derive what it already worked out? Fix that before you shop for a better model.

Write the blast-radius rule before the capability tempts you. Decide now what an unattended run is allowed to touch. A model that can operate any application for hours is only as safe as the credentials you handed it.

The launch argument was about whether this is the AGI era. The operator question is smaller and more useful: OpenAI found 37 points in the scaffolding around a model that was already trained.

Yours is untouched.