GPT-6 Astra puts computer use on the product roadmap. The hard part is still the commit. (2026)

OpenAI released GPT-6 Astra on September 3, 2026, describing it as a model for computer use, browsing, software engineering, and professional work. By September 4, OpenAI said Astra was available in its API and for Pro, Enterprise, and Business Premium users in ChatGPT Work and Codex. 1 2

The product signal is bigger than a new model score. Astra combines computer use with asynchronous tool calling, mid-response steering, and context retrieval across long Codex sessions. The practical question for a PM is whether those features make a workflow reliable enough to delegate, rather than whether a demo looks impressive.

Quick view

Signal	What the source says	PM implication	Action window
Computer use	Astra reports 72.6% on OSWorld 2.0 and about 47% less time per task than GPT-5.6 Sol under OpenAI's stated evaluation setup. 1	Test end-to-end completion time, including tool waits and review, rather than model latency alone.	Start with one reversible workflow this week.
Long-running work	Codex can preserve notes across context windows and search earlier messages and tool outputs. 1	Context persistence becomes part of the harness and needs its own correctness tests.	Audit current compaction and recovery paths before swapping models.
Human steering	Astra can ask a question while continuing work that does not depend on the answer, then wait on consequential choices. 1	The workflow needs explicit decision points, permissions, and a way to resume after a reply.	Design the handoff before granting write access.
Reality check	A September 2026 arXiv study of 1,258 commands from eight blind users found 52.5% success for GPT-5 in everyday desktop workflows. 3	Controlled benchmarks can overstate reliability when tasks involve hidden controls, constraints, and final commits.	Keep an independent state verifier in the first pilot.

What changed: the model can keep working while the user decides

Computer-use agents combine a language model with a browser or desktop controller. The model observes screenshots, interface structure, and recent actions. The harness turns the model's selected action into a click, keystroke, tool call, or file operation. A verifier checks whether the requested outcome actually happened.

Astra's release changes several points in that loop. OpenAI says the model can fill forms, update CRM records, organize calendars, research online, draft in a document editor, install and test software, and run frontend QA. OpenAI also says the Codex harness improves computer-use speed, and reports a 1.9x faster task-completion result than the GPT-5.6 Sol experience on Mind2Web under its stated setup. 1

The most useful interaction change is asynchronous steering. A user can answer a question about a consequential choice while Astra continues independent work. If no answer arrives, Astra can continue with reasonable assumptions where appropriate and pause when the decision could change the result. 1

That behavior changes the unit a team has to design. A prompt is no longer enough. The product must define what the agent may do alone, what requires confirmation, what evidence it must show, and how it resumes after a human decision.

The long-session problem moves into the harness

Long sessions create a familiar failure: the agent summarizes earlier work, loses a small requirement, and repeats a failed path. OpenAI says Astra's Codex integration can keep notes across context windows while leaving earlier context searchable. The feature is experimental in config.toml and is planned as the default for Astra in coming weeks. 1

The distinction matters for product architecture. A note is a memory artifact. Earlier tool output is evidence. A test result is a constraint. A production harness should keep those objects separately addressable, versioned, and tied to the task state. A single rolling summary makes it hard to tell whether the agent remembered a requirement, inferred it again, or silently dropped it.

OpenAI's September 1 engineering article makes a related operating point through Basis, Clay, and Exa Labs. The three companies connect agents to company context and tools, give recurring work a persistent structure, and keep tests or human review before consequential actions. 4 The article reports examples from those companies; the examples are implementation precedents, not independent validation of Astra's performance.

The reality check: screens still hide the hard cases

A paper posted on arXiv on September 1 studied computer-use agents with eight blind screen-reader users over three weeks. The study collected 1,258 commands across 12 desktop applications, then replayed the same commands with five models under a shared pipeline. GPT-5 had the highest observed success rate at 52.5%, followed by Claude Sonnet at 48.5%, Gemini 2.5 CU at 43.9%, UI-TARS at 39.8%, and Qwen3-VL at 37.9%. The GPT-5 lead over Claude was not statistically significant in the paper's paired test. 3

The failures explain why a benchmark score cannot become a product promise by itself. The paper reports errors in four places that a PM can test directly:

Grounding: the agent chooses a control or coordinate that the current interface does not support.
Path discovery: the agent handles a visible option but misses a setting behind a menu, dialog, or intermediate screen.
Constraint tracking: the agent completes one part of a request and drops another, such as changing a font without preserving the requested size.
Termination and commit: the agent repeats an action after progress stops, or reaches the right setting without performing the final Save or Apply action. 3

The paper's setting also matters. Participants chose which tasks to delegate, and some avoided sensitive tasks after repeated failures. The reported rates therefore describe the observed commands and replay conditions. They do not establish reliability for every desktop workflow or for production accounts. 3

A recent public walkthrough, GPT-6 Astra's Computer Use Is Ridiculously Good, is useful for seeing the interaction style. The video is an explainer and demonstration, not a controlled evaluation of the paper's tasks or of production reliability.

A bounded product path

Start with one workflow that has a reversible outcome and a machine-readable state. Examples include creating a draft ticket, preparing a pull request without merging it, or updating a test record in a sandbox. Avoid banking, production deletion, external messages, and irreversible changes in the first round.

Define the commit. Write the exact before-and-after state. A successful run needs an authoritative check such as a database diff, repository test, document property, or browser-visible confirmation that a separate verifier reads.
Keep the model and harness visible. Record the Astra version, system instructions, tool schemas, browser or desktop controller, context policy, permissions, retries, timeouts, and human-review rules. The deployment unit is the model plus this harness.
Use three arms. Compare the current workflow, the current workflow with Astra swapped in, and Astra with the new persistence or asynchronous-steering features enabled. Keep tasks, tools, permissions, and acceptance checks fixed.
Create difficult holdouts. Reserve hidden controls, changing page layouts, interrupted sessions, missing information, conflicting instructions, and final-commit steps for evaluation. Include tasks that require the agent to ask before writing.
Route authority outside the model. The verifier, permission layer, and rollback path should decide whether a side effect is accepted. A model's statement that it finished is evidence to inspect, not the state change itself.

Track verified completion, partial completion, constraint retention, recovery after interruption, false-success rate, repeated-trial consistency, first-side-effect timing, p50 and p95 end-to-end latency, tokens, browser minutes, cost per successful task, human intervention, permission denials, and unauthorized state changes. Track the time spent waiting for tools separately from the time spent reasoning.

Decision gate

Use this hypothesis: Astra plus the new harness controls will improve verified completion and recovery on held-out, reversible workflows while keeping cost, latency, and unauthorized state changes inside the team's budget.

Promote the pilot only when the gain survives fresh resets, hidden UI paths, interrupted sessions, and repeated seeds. Require an independent verifier for every write. Keep a direct human path and the current workflow as fallbacks. Treat a pause, a failed commit, or an unsupported assumption as an observable product event, not as an invisible retry.

GPT-6 Astra makes computer use easier to try. The product decision still rests on what happens at the last click: whether the requested state changed, whether the agent can prove that change, and whether a human can stop it before the wrong state becomes real.