GPT-6 in 7 Minutes: Astra, Sol, and Luna Explained for Developers

GPT-6 is a three-model family from OpenAI: Astra is the top-capability tier ($10 input / $50 output per million tokens), Sol is the everyday reasoning tier ($2 / $10), and Luna is the high-volume tier ($0.10 / $0.50). All three share a 1,050,000-token context window, take text and images in, and return text. You can try them today in the OpenAI API as gpt-6-astra, gpt-6-sol, and gpt-6-luna, and in Codex through a ChatGPT plan.

That is the answer the GPT-6 In 7 Minutes video walks through in 7 minutes and 12 seconds. This post is the written version for developers: the tier table, the new API features, the numbers worth remembering, and the exact ways to switch a project over.

Last updated: September 28, 2026. Model specs and prices were checked against OpenAI's model pages that day. The video had no captions available when we wrote this, so video-specific details come from its published description and chapter list, and every number below was re-checked against OpenAI's own pages.

Official Sources#

The Three Tiers at a Glance#

Astra also charges $12.50 per million tokens for cache writes. Requests that run past 272K tokens of context cost more; our Astra release guide has the long-context multipliers and the full benchmark table. OpenAI cut Sol and Luna prices by 50% against their GPT-5.6 promotional rates when it launched them, which is why the September price comparison with Opus 5.5 and Grok 4.7 looks so different from the summer one.

One detail that trips up migrations: Astra does not support the none reasoning effort, while Sol and Luna do. If a request uses none today, move it to low for Astra.

What the Video Covers#

The chapter list in the video description gives the shape of the seven minutes:

The through-line is computer use: a model that operates real software instead of only writing code about it. That is also why the 3D demos in the video matter. Building a detailed world in Unreal Engine is a test of an agent driving a large, stateful application. We built on that idea in two follow-up demos: a single-file Three.js world and a Blender scene that becomes a playable game.

The Numbers Worth Remembering#

All figures below are from OpenAI's launch announcement, where scores are the maximum at any effort level. They are vendor-reported, so treat them as a starting point for your own evals.

On the Codex side, OpenAI says it updated the harness alongside Astra and measured 1.9x faster task completion than the GPT-5.6 Sol experience on the Mind2Web benchmark.

One line in the video description deserves a precise reading. It mentions a 0% score on Exploit Gym. In OpenAI's table, the 0.0% figure is the "ExploitGym honeypot" alignment row, where lower is better: it measures whether a model facing an impossible task goes beyond its authorized scope, and GPT-5.6 Sol did so 48.2% of the time. It is not Astra's exploit success rate on the benchmark itself, which OpenAI reports as 42.4%. Astra is also the first OpenAI model rated Critical for cybersecurity, so the launch version refuses advanced offensive tasks like writing proof-of-concept exploits. The safety write-up covers what that means in practice.

Three New API Features#

The API guide lists what is new for GPT-6. These are the ones that change how you build agents:

1. Async tool calling. Set async: true on a function or custom tool and the model keeps reasoning, calls other tools, or answers independent parts of the request while your application runs the tool. You return the result later using the original call_id. Your application still executes the tool and tracks pending work.
2. Mid-turn steering. You can send extra user instructions while the model is working, such as a correction or a changed requirement. Over a WebSocket connection, the Responses API preserves completed work and folds the update into a continuation.
3. Reasoning changes that keep the cache. Add a configuration_update input item to raise or lower reasoning effort without rewriting the prompt prefix. Keep request-level reasoning.effort unchanged so the cached prefix survives.

For coding agents, the practical effect is fewer restarts. A long session can take a correction at minute 20 instead of being killed and replayed, and a cheap follow-up can drop to low effort without paying to re-read the whole context.

How to Try Each Tier#

In Codex. Astra, Sol, and Luna are available through ChatGPT plans that include them (Sol and Luna for Plus, Pro, Business, Enterprise, and Edu; Astra rolled out to Plus, Pro, Business, and Enterprise, with Enterprise admins switching it on per workspace). From the terminal, the -m flag picks the model:

codex -m gpt-6-astra
codex exec -m gpt-6-sol "Find why the integration tests in ./api are flaky and fix the root cause"

We confirmed the -m, --model flag against codex --help on codex-cli 0.155.0. New to the CLI? Start with OpenAI Codex in 7 Minutes.

In the API. Set model on a Responses API request and choose an effort level:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-sol",
    "input": "Summarize the failing tests in this log and propose a fix.",
    "reasoning": { "effort": "medium" }
  }'

Use the Responses API for anything with tools. The API guide says Astra supports Chat Completions, but its tool calling requires Responses, and Sol and Luna support function calling in Chat Completions only with reasoning_effort: "none".

Which Tier to Pick#

A cheap test that pays for itself: run one real task from your backlog on Sol and on Astra, log cost and wall-clock time, and only move to Astra where it removes retries. OpenAI's own numbers say Astra often uses fewer output tokens per task, but at five times Sol's per-token price, that has to show up in your logs before it counts.

Watch the Video#

GPT-6 In 7 Minutes is the fastest way to see the computer-use and 3D examples in motion, which a table cannot show. The chapter at 03:50 is the one to scrub to if you only have a minute.

FAQ#

What is GPT-6?#

GPT-6 is OpenAI's model family with three tiers: GPT-6 Astra (most capable), GPT-6 Sol (balanced), and GPT-6 Luna (efficient, high volume). Astra launched first, in early September 2026, and Sol and Luna followed on September 22.

How much does GPT-6 cost?#

Per million tokens: Astra is $10 input and $50 output, Sol is $2 and $10, and Luna is $0.10 and $0.50. Cached input is $1, $0.20, and $0.01 respectively.

How do I use GPT-6 in Codex?#

Pick the model in Codex on a ChatGPT plan that includes it, or pass -m gpt-6-astra, -m gpt-6-sol, or -m gpt-6-luna to the Codex CLI. Enterprise workspaces need an admin to enable Astra.

Does GPT-6 accept audio or video input?#

The API model pages list text and image input with text output for all three models. Audio and video are not listed as inputs.

What is async tool calling?#

It is a GPT-6 API feature where a tool marked async: true runs in your application while the model keeps working on independent parts of the request. You send the result back with the original call_id when it is ready.

Sources#

Continue Reading#

• GPT-6 Astra Release Guide - the full benchmark table, Astra safeguards, and OpenCode commands
• GPT-6 Sol vs Claude Opus 5.5 vs Grok 4.7 - the September price war in one comparison
• GPT-6 World Building: One HTML File to an Interactive Three.js World - the 3D follow-up demo
• GPT-6 and Blender: Build a Playable 3D Game With Codex and AI Video - Astra driving Codex through Blender
• OpenAI Codex in 7 Minutes - the CLI basics before you switch models