Is GPT-6 called Astra?

The Short Answer: Yes, GPT-6 Is Officially Called Astra

If you've seen "Astra" floating around in AI news and wondered whether it's a rumor, an internal codename, or the real thing, here's the definitive answer: GPT-6 is officially called Astra. OpenAI's own developer documentation lists the flagship model with the API identifier gpt-6-astra, which settles the question as firmly as anything in this industry gets settled.

The name isn't a placeholder or a leak. It's part of a deliberate rebranding. OpenAI has moved away from the familiar version-number scheme (GPT-4, GPT-4o, and so on) toward a celestial naming convention for the GPT-6 family, where each tier of the lineup is named after a celestial body. According to the official model documentation, the family breaks down like this:

• Astra is the flagship, positioned as OpenAI's most capable and most intelligent model.
• Sol offers near-Astra performance for complex work at a lower cost.
• Luna is the most efficient model, built for focused, high-volume tasks.

Why drop version numbers? Because the tiers now signal capability and price positioning, not just a version increment. The pattern actually started earlier: GPT-5.6 already shipped as Sol and Luna, so Astra extends an existing naming system rather than inventing one overnight. When you see a celestial name, you immediately know where a model sits in the lineup, which is arguably more useful than knowing it's "version 6 point something."

The branding also reflects a bigger positioning shift. OpenAI frames Astra as a move "from chatbots to digital workers," a model that can operate browsers, spreadsheets, and desktop applications directly, and OpenAI President Greg Brockman tied the launch to the arrival of the "AGI era" in comments to VentureBeat. Brockman even argued that "pricing tokens doesn't make any sense," pushing customers to think in terms of price per completed task instead.

A note of caution on the hype: the name and the AGI framing are official, but independent evaluations are more measured. Artificial Analysis scores Astra at 61 on its Intelligence Index, equal to GPT-5.6 Sol and below Claude Fable 5.1, though Astra is 70% more token-efficient than GPT-5.6 Sol.

For teams building agents around Astra, the model name is only half the equation; the skills you equip it with matter just as much. SkillzBench's free directory lets you verify and benchmark agent skills before you attach them, and the free MCP connector lets you equip your agent with only the skills you've chosen.

Why OpenAI Switched to Celestial Names and 'Digital Worker' Branding

OpenAI didn't just rename its flagship model. It rebranded what an AI product is supposed to be.

The shift from numerical versioning (GPT-4, GPT-4o) to celestial codenames signals a deliberate move away from incremental updates toward capability tiers. According to OpenAI's developer documentation, the GPT-6 family now includes three distinct models organized by performance profile:

• Astra, Flagship tier, positioned as "most capable" and "most intelligent"
• Sol, Balanced tier, offering "near-Astra performance for complex work at a lower cost"
• Luna, Efficient tier, designed for "focused, high-volume tasks"

This naming pattern echoes earlier releases like GPT-5.6 Sol and GPT-5.6 Luna, suggesting OpenAI is standardizing celestial branding across its entire lineup. The astronomical vocabulary does more than differentiate products. It frames each model as a distinct entity with a defined role, rather than a version number that implies simple progression.

The deeper branding play centers on agency. OpenAI positions Astra not as a chatbot but as a "digital worker" that operates browsers, spreadsheets, and desktop applications directly. OpenAI President Greg Brockman framed the launch as the onset of the "AGI era," stating, "Welcome to the AGI era" in coverage by VentureBeat. That language reframes the product category entirely: you're no longer buying text generation, you're hiring an autonomous agent.

Pricing philosophy follows the same logic. Brockman argued that "pricing tokens doesn't make any sense" and that customers should evaluate cost per completed task instead. OpenAI claims Astra is 70% more token-efficient than GPT-5.6 Sol, which means a higher per-token rate ($10 per million input, $50 per million output) can still translate to lower total cost per workflow. Analyst Nic Dunz estimated Astra is only 5–10% better for general use but about 75% more expensive per task at maximum effort, highlighting why the per-task framing matters for ROI calculations.

For businesses building on these agentic capabilities, the quality of the tools and instruction packages that Astra relies on becomes critical. SkillzBench's free directory and MCP connector let you discover, verify, and benchmark agent skills before equipping your "digital worker" with them, so the autonomy OpenAI is selling doesn't outpace your ability to trust what it's doing.

The Marketing vs. the Benchmarks: What Astra Actually Delivers

You need to look past the marketing hype to see if the price tag is worth the performance. OpenAI claims GPT-6 Astra is their most intelligent model yet, but independent data tells a more complex story about actual value.

The vendor highlights impressive benchmarks, such as a 99.9% score on ARC-AGI-3. They also claim a 70% gain in token efficiency compared to previous versions. These figures suggest a massive leap in capability and cost-effectiveness for high-volume tasks.

However, third-party evaluations paint a different picture. Artificial Analysis rates Astra at 61 on its Intelligence Index. This score is identical to GPT-5.6 Sol and lower than Claude Fable 5.1, which scores 66. This discrepancy raises questions about whether the "AGI era" branding matches real-world output.

Analyst Nic Dunz estimates Astra is only 5–10% better for general use. Meanwhile, the model costs roughly 75% more per task at maximum effort. This gap between perceived capability and actual utility is critical for budget planning.

Consider the pricing structure carefully before committing to an enterprise rollout.

• Astra costs $10 per million input tokens and $50 per million output tokens.
• GPT-6 Sol is five times cheaper for input tokens.
• GPT-6 Luna is one hundred times cheaper than Astra.
• Fast Mode doubles the cost but offers up to 2.5x speed.

OpenAI argues that pricing should shift from tokens to completed tasks. They claim the estimated API cost per task is lower due to efficiency gains. Yet, you must verify this in your specific workflow.

For agent builders, the focus should be on verifying skills rather than just model tiers. SkillzBench runs free benchmarks that test agent skills in a sandbox. This helps you see if a specific tool actually improves performance.

You can use the free MCP connector to equip your agents with verified skills. This ensures your "digital worker" uses safe and effective tools. The platform shows Lift results separately from ratings, so money never influences scores.

Check the current numbers and verified results at skillzbench.com. This approach helps you judge value based on proven outcomes, not just vendor claims.

Choosing the Right Tier and Running It Safely: A Practical Playbook

The celestial naming isn't just branding; it's a decision framework. Once you know what Astra, Sol, and Luna each stand for, picking the right model for a job becomes surprisingly straightforward.

Start with the job, not the model. Astra earns its flagship price ($10 per million input tokens, $50 per million output) when you need autonomous computer use on systems that lack modern APIs: legacy ERP screens, desktop apps, internal tools nobody wants to rebuild. It scored 72.6% on OSWorld 2.0's offline subset, ahead of GPT-5.6 Sol's 65.7%, and OpenAI reports it produced unintended outcomes 89% less often than Sol on its internal computer use safety benchmark, per the company's product announcement.

Sol and Luna cover everything else. Sol delivers near-Astra performance at a fifth of Astra's input cost, while Luna runs roughly 100x cheaper and fits focused, high-volume work like classification, extraction, and routing. A useful rule of thumb:

• Astra for complex, multi-step autonomous work on legacy apps without APIs
• Sol for hard tasks where near-flagship quality matters but cost does too
• Luna for routine, high-volume tasks where efficiency wins

Whatever tier you pick, don't skip the monitoring question. The UK AI Safety Institute found Astra's reasoning summaries were missing up to 80% of long simulated cyber trajectories, which means you often can't see what the model actually did on extended autonomous runs, as aggregated third-party evaluations note. OpenAI's own chief scientist, Jakub Pachocki, has said progress in intelligence doesn't guarantee progress in alignment. The practical answer is external validation and human-in-the-loop checks on any consequential action, not trust in the model's self-reported reasoning.

Finally, change how you measure cost. Greg Brockman put it bluntly: "Pricing tokens doesn't make any sense." Astra is 70% more token-efficient than GPT-5.6 Sol, so a higher per-token price can still mean a cheaper completed task. Analyst Nic Dunz estimates Astra is only 5–10% better for general use but roughly 75% more expensive per task at max effort, which makes cost per completed task the only metric that tells you the truth.

If you're wiring these models into agent workflows, the skills you attach matter as much as the tier you choose. SkillzBench's free directory benchmarks agent skills with and without each one and publishes the measured Lift, and its free MCP connector lets you equip any model with only the verified tools you've picked. Skills, proven, before you let a digital worker loose on production.

Equipping Astra with Verified Skills: Your Next Step

Astra's value as a "digital worker" comes from what it can do on your machine: operate browsers, spreadsheets, and desktop apps directly. But an agent is only as good as the skills and tools you attach to it, and most people attach them without checking what they're actually installing.

That's not a theoretical worry. Published research found that roughly 26% of agent skills carry at least one vulnerability, meaning about one in four instruction packages could expose your workflow to risk. When you hand an agent like Astra autonomous control over software, an unvetted skill is an unvetted employee with keys to the building.

The problem is that agent skills, which are SKILL.md instruction packages for tools like Claude Code, Codex, Cursor, Gemini CLI, and chat-app agents, are everywhere and growing fast. Nobody has time to read every one, and a skill that looks helpful can still be poorly written, license-tainted, or quietly risky. That's the gap SkillzBench was built to close, and it's live today at skillzbench.com.

The platform works across five pillars:

• Discover: continuously crawls and dedupes skills from GitHub, so you're browsing a real catalog rather than scattered repos.
• Verify: pins every version to a commit SHA, then validates, license-checks, security-scans, and quality-judges each skill.
• Benchmark: tests every skill in a sandbox with the same model, with and without the skill, and publishes the Lift in percentage points separately from ratings.
• Equip: provides one free MCP server plus per-agent loadouts, so you toggle exactly which skills and tools each agent can see.
• Stay current: tracks upstream changes, re-scans, re-benchmarks, and notifies you when something shifts.

Each skill gets a trust score from 0 to 100, built from security, quality, license, maintenance, and community signals. The Lift results are published separately, and money never touches scores, so what you see reflects the skill, not a sponsor. Everything on the platform is free: the directory, the benchmarks, the alerts, and the MCP connector.

The per-agent loadout model matters most for agentic models like Astra. OpenAI's own materials emphasize enterprise controls that restrict access and require confirmation for consequential actions, and chief scientist Jakub Pachocki has been explicit that progress in intelligence does not guarantee progress in alignment. Giving your agent only the verified skills you chose is the practical version of that principle: least privilege, applied to instructions.

So if you're evaluating Astra for real work, treat the model as half the equation. The other half is what you equip it with. Browse verified skills, check the trust scores and Lift results, and connect your agent through the free MCP tool so it only ever sees what you selected.

Skills, proven.