Inside GPT-6 Astra: The Model Powering Dots

Every dot's judgment — what it decides is worth flagging, what it treats as consequential enough to hold for your approval, how it interprets a vague instruction like "keep the launch deck current" — traces back to one model: GPT-6 Astra. And yet, for a model asked to run unsupervised across a browser, a filesystem, and thousands of third-party apps, OpenAI has said comparatively little about it in public. That gap is worth naming plainly rather than papering over with confident-sounding filler.

What OpenAI has actually confirmed

The concrete claim, repeated across OpenAI's DevDay announcement and the press coverage that followed, is simple: dots run on GPT-6 Astra. That's the extent of the specification most outlets received. MacRumors' coverage adds one useful piece of context by contrast — OpenAI separately introduced a distinct model, GPT-6.1 Sol, on the same day, described as bringing "improvements in agentic coding, computer use, and professional work." That Astra and Sol shipped as two different named models in the same announcement, rather than one model doing everything, is itself informative: OpenAI appears to be routing "the model that drives an autonomous, always-on agent" and "the model that's best at coding and computer-use tasks in a supervised session" down separate tracks, at least for now.

What that split implies — that Astra is tuned specifically for the judgment calls an unsupervised agent has to make, rather than for raw coding throughput — is a reasonable inference, not a confirmed fact. OpenAI hasn't published a model card, benchmark suite, or technical explanation of what makes Astra suited to the dot use case beyond the name itself. Where the reporting is silent, this article stays silent too, rather than inventing capability claims to fill the gap.

Why the silence matters more here than usual

OpenAI has, in the past, launched flagship models with detailed benchmark comparisons, safety evaluations, and architecture notes. The comparative quiet around Astra stands out precisely because of what it's being asked to do differently from a normal chat model: make autonomous decisions about which actions require human sign-off, run "proactive research" against read-only tools without being asked, and operate for extended stretches without a human in the loop reviewing every step.

Those are exactly the kinds of capabilities where independent evaluation — red-teaming, third-party safety testing, published reasoning about failure modes — tends to matter most. OpenAI's own safety framing for dots leans heavily on product-level controls layered on top of the model: Custom Rules, Auto-Review, and the Activity View, rather than model-level transparency about Astra's training or evaluation. That's a legitimate design choice — guardrails around a system can be just as meaningful as disclosures about the system itself — but it's a different kind of trust than "here's the model card," and worth naming as such rather than assuming the wrapper substitutes for the disclosure.

What "computer" really means for Astra

The other confirmed detail that matters for understanding the model in practice: every dot pairs Astra with its own cloud computer and browser, described by MacRumors as functioning "much like Muse" — Meta's competing agent, which runs its own agent inside an isolated VM called the Muse Secure VM. That's a meaningful architectural signal: Astra isn't reasoning in the abstract and issuing instructions to your existing browser session. It's operating inside a dedicated environment, which is both a safety boundary (a compromised or confused dot session can't directly touch your machine unless you've explicitly connected it) and a capability question in its own right — how well Astra uses that environment, how reliably it navigates a real website's UI, how it recovers from a page that didn't load the way it expected. None of that has been benchmarked publicly as of this writing.

The model card is missing, but the sandbox is documented. For now, OpenAI is asking users to trust the guardrails around Astra more than Astra itself.

What to actually watch for

If you're deciding how much autonomy to grant a dot, the honest position given the current information is this: judge Astra by what it does inside the rules you set, not by assumed benchmark superiority. The Custom Rules and Auto-Review system is the actual lever you control, and it's designed to matter regardless of exactly how capable the underlying model turns out to be in practice. That's also the more useful comparison point against xAI's Grok Bot and Meta's Muse Spark — none of the three companies has published detailed, independently verifiable model specifications for the agent driving their respective product, and all three are, for now, asking users to evaluate the product wrapper rather than the model underneath it.

That's not necessarily a red flag on its own — plenty of genuinely safe, well-engineered products ship without a public model card, particularly at this velocity of release. But it is a gap between what a "GPT-6 Astra" name implies (a specific, evaluable model with known behavior) and what's actually been disclosed (a name, attached to a product, attached to a sandboxed computer). Anyone building a workflow around a dot right now is doing so on OpenAI's word about the guardrails, more than on independently verifiable claims about the model inside them.

A naming pattern worth tracking

OpenAI's habit of pairing a numbered model generation with a distinct codename — Astra for the always-on agent, Sol for the coding- and computer-use-focused release announced the same day — is itself a useful signal for anyone trying to track this fast-moving space from the outside. It suggests OpenAI now treats "which model powers which product" as a meaningful branding decision in its own right, not an afterthought. That makes the codename, rather than the numbered generation, the more reliable thing to search for when trying to find out what's actually running under a given feature months from now, since the underlying "GPT-6" designation is likely to accumulate several differently tuned variants over time without each one getting its own headline announcement.

It also means comparisons across products need to specify which variant is doing the work, not just which company. "OpenAI's model" isn't a single, comparable thing anymore — dots run on Astra, Codex-style coding tasks may lean on Sol or a successor, and neither claim tells you anything reliable about the other's behavior. That's a small piece of vocabulary worth carrying into the rest of this series, since later articles reference specific capabilities that trace back to specific, named models rather than to "OpenAI" as an undifferentiated whole.

Which is precisely why the next piece of this series is about what that computer actually is, and what having one really changes — because the model's judgment only matters in the context of the environment it's allowed to act inside.

Part 2 of 30 in the ChatGPT Dots series. Previously: What Is a "Dot"? OpenAI's Always-On Agent, Explained. Next: Every Dot Gets a Computer: What That Actually Means. Browse more builder insights or explore AI skills at aiskill.market.