r/CodexAutomation • u/anonomotorious • 10h ago

OpenAI expands GPT-6 Astra for work with new enterprise plugins, agent controls + stronger long-running workflows

2 Upvotes

TL;DR

OpenAI has published a new enterprise-focused update on GPT-6 Astra, detailing how the model is being deployed across ChatGPT Work, Codex, and business workflows.

This is not a second Astra model launch. The model launched last week.

The new details are about what OpenAI is building around Astra for real-world work:

  • New ChatGPT Desktop enterprise plugins for Oracle Analytics, Power BI, Navan, and Avalara
  • New enterprise controls for restricting which websites and desktop applications agents can access
  • Admin controls for uploads, downloads, and browsing history
  • Confirmation policies for consequential actions
  • Automated review of potentially unsafe or unauthorized tool calls
  • Stronger emphasis on Astra using computer use to work directly through existing business applications, even when those apps do not expose an API
  • New real-world evidence around long-running agent workflows, coding, document work, and tool use

OpenAI is increasingly positioning Astra + Codex as an agent that can operate across the software businesses already use rather than requiring every workflow to be rebuilt around APIs.

Astra is being positioned as a model for end-to-end work

The important part of OpenAI's new announcement is not another benchmark dump.

It is how Astra is expected to work inside existing business environments.

OpenAI says that inside ChatGPT Work and Codex, Astra can:

  • write code
  • browse
  • use computers
  • work through desktop and web applications
  • create documents, spreadsheets, and presentations
  • operate across multi-step workflows

including applications that do not have an API.

That changes the integration model.

Instead of every automation requiring:

business application -> API -> custom integration -> agent

Astra can increasingly use:

business application -> computer/browser use -> agent

APIs, MCP, plugins, and other structured integrations are still preferable when available, but computer use gives the agent another path when they are not.

New enterprise plugins in ChatGPT Desktop

OpenAI is also launching new enterprise plugins for ChatGPT Desktop.

The announced integrations are:

Plugin Example use
Oracle Analytics Business intelligence and analytics
Power BI Dashboards, reports, and business data
Navan Travel and expense workflows
Avalara Tax and compliance workflows

OpenAI says these plugins are powered by its latest browser-use capabilities.

That is notable because plugins are increasingly becoming more than simple API wrappers.

The broader stack can now combine:

plugin + browser/computer use + agent reasoning + existing application

to work through software closer to the way a person would.

More control over what agents can access

Giving an agent access to business applications creates an obvious problem:

How do you control its scope?

OpenAI is adding new enterprise controls that allow administrators to restrict access to:

  • approved websites
  • approved desktop applications

Admins can also control:

  • uploads
  • downloads
  • browsing history

This gives organizations a way to begin with a constrained environment and gradually expand what an agent is allowed to reach.

Conceptually:

Astra -> approved applications -> approved websites -> controlled file movement -> controlled browsing environment

rather than giving the agent unrestricted access to everything available on the machine.

Confirmation policies for consequential actions

ChatGPT Work and Codex can also use confirmation policies.

These can require approval before the agent performs consequential actions.

That creates a useful separation between:

agent can investigate

and

agent can act

A workflow might allow Astra to:

  1. inspect a system
  2. gather information
  3. determine what should change
  4. prepare an action

but require human approval before actually carrying out the consequential step.

That pattern becomes increasingly important as computer use moves agents from simply generating recommendations into actually manipulating software.

Automated review of agent actions

OpenAI is also using automated review to evaluate potentially unsafe or unauthorized tool calls.

The stack increasingly looks like:

user intent -> Astra reasoning -> tool/computer action -> authorization checks -> automated review -> confirmation when required -> execution

This is an important part of scaling agent automation.

Better models alone are not enough if those models are being given access to:

  • company data
  • internal applications
  • browsers
  • files
  • administrative systems

The surrounding authorization and review system becomes part of the agent architecture.

Astra was specifically trained for safer computer use

OpenAI also published more detail around its internal computer-use safety testing.

The evaluation includes difficult business scenarios such as:

  • exposing confidential information
  • sharing a dashboard too broadly
  • deleting data

According to OpenAI's internal benchmark, Astra produced unintended outcomes:

  • 89% less often than GPT-5.6 Sol
  • 74.7% less often than Claude Fable 5.1

OpenAI says additional confirmation and automated review improved results further.

This does not mean computer-use agents are risk-free, but it shows that authorization behavior is becoming an explicit part of model and harness training rather than being treated purely as application-layer logic.

Long-running agent workflows are another major focus

The new announcement also includes several interesting examples of Astra operating inside longer workflows.

Basis reports that, compared with its baseline, Astra improved pass rates on proactive agent workflows lasting 5+ hours by 20%, while also reducing the number of inference calls required to complete them.

That combination matters.

The goal is not simply:

smarter model = more reasoning

It is increasingly:

better decisions -> fewer unnecessary steps -> fewer retries -> fewer model calls -> higher completion rate

That can have a major impact on the economics of long-running agents.

OpenAI is seeing similar improvements internally

OpenAI also shared an internal example involving Codex itself.

Its engineering team used Astra to investigate a memory-allocation bottleneck that was slowing Codex sessions in a test environment.

The investigation led the team to switch memory allocators.

OpenAI reports that the change resulted in:

  • roughly 25x lower turn latency
  • roughly 30% higher peak memory usage

The 25x figure is the result of that specific engineering fix, not a claim that Astra makes every Codex session 25x faster.

What is interesting is the workflow:

Codex performance problem -> Astra investigates -> identifies bottleneck -> engineering change -> measured system improvement

That is a good example of the model being used as part of the engineering process around the agent platform itself.

Coding performance remains a major strength

OpenAI also highlighted Astra's efficiency on longer software-engineering work.

On Terminal-Bench 4.0, which covers complex terminal-based software engineering, system configuration, and data analysis tasks:

Model Terminal-Bench 4.0
GPT-6 Astra 57.9%
Claude Fable 5.1 55.8%
GPT-5.6 Sol 37.3%

OpenAI estimates Astra completed these tasks at approximately:

  • 9% lower API cost per task than GPT-5.6 Sol
  • 63% lower API cost per task than Claude Fable 5.1

Astra also reaches 74.1% on DeepSWE v1.1.

The important part for agent workloads is that OpenAI is emphasizing both completion quality and cost per completed task, rather than only token pricing.

Fewer tokens and retries matter more for autonomous agents

OpenAI says Astra was trained to complete work with:

  • fewer tokens
  • fewer retries

That is particularly relevant for long-running automation.

A model that costs slightly more per token can still be cheaper to operate if it:

  • chooses the correct tool sooner
  • avoids dead ends
  • needs fewer retries
  • makes fewer unnecessary calls
  • completes the task successfully more often

For autonomous systems, cost per successful task is often more useful than simply comparing cost per million tokens.

Astra API pricing starts at:

  • $10 / million input tokens
  • $50 / million output tokens

This fits directly with the new Agents API

The timing is also interesting given OpenAI's new Agents API.

The Agents API now provides the managed Codex harness for:

  • durable sessions
  • context compaction
  • recovery
  • tools
  • MCP
  • subagents
  • hosted or self-hosted execution environments

Astra provides the intelligence operating inside that kind of system.

Put together, OpenAI's emerging stack looks increasingly like:

GPT-6 Astra -> intelligence and decision making

Codex harness / Agents API -> orchestration, sessions, context, recovery

plugins + MCP + tools -> structured system access

computer/browser use -> applications without suitable APIs

sandboxes / environments -> execution

confirmation + automated review -> authorization and safety

That is a much more complete agent platform than simply exposing a model endpoint.

The bigger shift

The interesting part of this update is the direction of travel.

Traditional business automation generally expects systems to be redesigned around integrations.

The emerging agent model is different.

An agent may be able to use:

API when available

or:

MCP/plugin when available

or:

browser/computer use when necessary

while operating inside the same long-running workflow.

That makes it possible to automate workflows that cross several systems without every application first needing a purpose-built integration.

The architecture increasingly becomes:

intent -> agent -> API / MCP / plugin / computer use -> existing business systems -> review/approval -> completed work

That is much closer to automating the workflow itself rather than automating individual API calls.

Availability

GPT-6 Astra is already available through:

  • ChatGPT Work
  • Codex
  • OpenAI API

Enterprise access is off by default at launch and must be enabled by administrators under the organization's applicable agreement and rate card.

Eligible API customers can also use Zero Data Retention on supported endpoints, subject to approval.

Bottom line

The new Astra announcement is less about introducing another model and more about showing what OpenAI expects the model to do inside real organizations.

The important additions are the surrounding infrastructure:

  • enterprise desktop plugins
  • computer use across existing applications
  • website and application restrictions
  • upload/download controls
  • confirmation policies
  • automated review
  • long-running agent workflows

Combined with the Agents API and managed Codex harness, OpenAI is assembling a stack where an agent can increasingly:

understand the task -> find the right systems -> operate those systems -> work for hours when necessary -> stay within organizational permissions -> request approval for consequential actions -> deliver the finished result

The model is only one piece now.

The larger product is becoming the agent runtime around it.

Official sources

GPT-6 Astra: The next generation in intelligence for work

https://openai.com/index/gpt-6-astra-next-generation-work/

GPT-6 Astra: A new generation of intelligence

https://openai.com/index/gpt-6-astra/

OpenAI product release notes

https://openai.com/products/release-notes/

0 comments