GPT‑6 Astra, GPT‑6.1 Sol and Luna: agent models, costs and migration
September 30, 2026 update: GPT‑6.1 Sol and DevDay
OpenAI's API changelog dates GPT‑6.1 Sol to September 29, 2026. Coverage by Jirka Herník and Marek Bartoš prompted this review. Near-Astra performance is OpenAI's assessment, not a benchmark we ran.
Standard API rates per million tokens, up to 272K input tokens, are $2 input, $0.10 cache reads, $2.50 cache writes and $10 output. Basic input and output rates are unchanged from the original Sol; cache reads cost half as much. That does not halve an agent's total bill. The model documentation doubles input and cache rates and multiplies output by 1.5 for longer requests; regional processing adds 10%.
Check compatibility before switching
The migration guide identifies a breaking difference: GPT‑6.1 Sol supports neither none nor minimal reasoning. Tools require the Responses API; Chat Completions remains available without tool calling. An existing Sol configuration needs review.
In n8n, I would clone the difficult-complaints branch into a test workflow. Run original Sol, 6.1 Sol and Astra on identical cases, comparing decision quality, retries, time to approval and total cost including review. For a branch currently using none, measure the move to low separately. Keep routine classification on the inexpensive router initially, with a simple switch back to the original worker.
Two changes for longer agent runs
The September 29 changelog also adds computer use to Agents API and Ultrafast for Astra. The former provides a hosted browser, with website access approvals and sign-in handled by the application. The latter speeds output-token generation and does not support EU inference residency.
For invoices, I would reserve browser control for a supplier portal without a usable integration, preserve evidence of the result and require review before writing business records. Faster generation may do little for a workflow that spends most of its time waiting for OCR or CRM calls.
Historical context: the older sections retain previous models and launch availability. The current changelog dates Astra to September 3 and Agents API to September 10; the original text gave September 4 for Astra. This explicitly corrects that date.
September 24, 2026 update: Sol and Luna change the routing decision
OpenAI released GPT‑6 Sol and GPT‑6 Luna on September 22, according to its API changelog. This update follows Jirka Herník’s September 23 episode. The video date is separate from the release date.
The practical change is a pair of cheaper models alongside Astra. Standard API prices in USD per million tokens, for requests with no more than 272,000 input tokens:
| Model | Input | Cache read | Cache write | Output |
|---|---|---|---|---|
| GPT‑6 Sol | 2 | 0.20 | 2.50 | 10 |
| GPT‑6 Luna | 0.10 | 0.01 | 0.125 | 0.50 |
Above that threshold, the pricing page doubles input and cache rates and applies 1.5 times the output rate to the entire request. A short email and a large archive have different unit economics.
Both Sol and Luna support reasoning none. Chat Completions function calling requires that setting; use Responses for an agent that combines reasoning and tools. EU data residency is available only with Standard processing. Recheck Astra configurations and Fast-mode assumptions before reusing them.
Where I would put them
In n8n or Make, I would trial Luna for ticket classification, queue selection and extraction of a small, fixed set of fields. Sol would be a candidate for the main worker handling a difficult complaint or code change. Astra would remain an escalation path for contradictory evidence, broad audits and cases that repeatedly fail review. These are proposed pilot roles, not measured guarantees.
For invoices, ask for verifiable fields and a list of discrepancies. Let code check totals, currency, duplicates and purchase-order matching. Missing evidence or a mismatch should enter a review queue. Cheaper inference does not justify automatic payment approval.
The same model can produce a different bill
The episode compares agent costs. A ranking of Pi, Codex and Claude Code needs matching tasks, context, effort, tools and completion criteria. Different agents may resend more history, use caching differently or repeat failed steps.
Measure cost per approved outcome, including tokens, paid tools, retries, escalations and human review. Keep API spending separate from application subscriptions. Run the same historical cases through the proposed route and the existing baseline before changing production defaults.
Historical context: the Agents API update and original Astra analysis remain below. Their GPT‑5.6 price comparisons and launch availability describe the earlier situation. Use this update and the linked live pricing page for current model selection.
September 22, 2026 update: Agents API adds managed execution
Alongside low-level model orchestration, consider Agents API, discussed in AI mastermind 40 on September 17. That date refers to the video, not a verified initial API release date.
The documentation describes a managed Codex harness with sessions, tools, skills and code-execution environments. This changes what the application implements: a custom Responses loop owns its orchestration, while Agents API exposes a longer-lived session and its state. It is more than a renamed model request.
For n8n, I would submit a task, persist its session ID and process completion through an event or webhook. The workflow need not hold one long HTTP request open. “Needs input” belongs in a human review queue; duplicate events must not create duplicate invoices or tickets.
Before a pilot, verify account availability, execution environment, network permissions and billing. A managed harness takes over some implementation work. Approval of external actions, task limits and the audit trail still need an application-level design.
GPT‑6 Astra is not a model I would put behind every prompt. At $10 per million input tokens and $50 per million output tokens, it costs 2.5 times as much as GPT‑5.6 Sol. It can still be cheaper per completed task for a narrow class of agents because it changes how an application can manage long-running work.
OpenAI introduced the model on September 4, 2026. It is initially rolling out to enterprises in the Trusted Access Program, with API and Plus, Pro, Business and Enterprise access expected over the following days. Documentation is live, but availability may not be immediate on every account.
What changed beyond GPT‑5.6
Astra provides a 1.05-million-token context window, up to 128k output tokens and reasoning effort from low through max; none is not supported. It supports the major GPT‑5.6 tools, including web and file search, code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search.
Three new controls matter most for production agents.
Asynchronous tool calling lets the model continue reasoning or work on independent parts while a slow export, render, database query or external API runs. Your application marks a function or custom tool with async: true, runs the tool itself and later returns the result using the original call_id.
Mid-turn steering lets a user correct direction, add a requirement or change a priority while the agent is running. Over WebSocket, completed work is preserved and the new instruction becomes part of the continuation.
Reasoning changes without rebuilding the prompt prefix use a configuration_update item. A workflow can raise effort for a hard exception and lower it again for routine follow-up while preserving the cached stable prefix.
Async agents need durable state
An async tool call does not make your application parallel by itself. OpenAI explicitly leaves tool execution and pending-work management to the application.
Each pending operation should carry a run_id, call_id, status, owner, timeout, retry count and idempotency key. Results must return to the correct call even when they arrive late or out of order. A worker restart should resume the run from state stored outside the model context.
In invoice processing, an agent can start OCR, supplier verification and purchase-order retrieval at the same time. While OCR is pending, it can prepare the validation schema and check the currency or tax ID from available data. Once all results arrive, it reconciles them and sends only exceptions to a human.
CRM enrichment can query a company registry, the public website and internal history in parallel. An incident agent can wait for a log export while reviewing recent repository changes. The value comes from shortening a real critical path, not from maximizing concurrency.
Astra belongs in an escalation tier
Standard API pricing is $10 per million input tokens, $1 for cached input, $12.50 for cache writes and $50 per million output tokens. Batch and Flex cost half of Standard; Fast costs twice the applicable rate. Requests above 272k input tokens price the full request at twice the input and cache rates and 1.5 times the output rate.
GPT‑5.6 Sol costs $4/$0.40/$20 for input, cached input and output; Terra costs $2/$0.20/$12 and Luna $0.20/$0.02/$1.20. Astra should earn its place by reducing retries, tool calls or review cycles on difficult work.
A practical router might use Luna for email, ticket and lead classification; Terra for standard extraction and JSON; Sol for complex cases and coding; and Astra for a long incident, cross-system audit, difficult refactor or an exception where repeated failure is more expensive than one stronger run.
Measure cost per resolved ticket, matched invoice, accepted pull request or audit that passes review. Per-token price is only an input to that decision.
API migration traps
Migration requires more than changing the model ID to gpt-6-astra.
OpenAI recommends the Responses API for tools. Astra supports Chat Completions, but its migration guidance ties tool calling to Responses. Remove unsupported parameters including temperature, top_p and top_logprobs; also remove logprobs in Chat Completions and message.output_text.logprobs from Responses includes.
If the current integration uses none or minimal reasoning, begin testing with low. Change effort between turns through configuration_update rather than rebuilding the request-level prefix when cache preservation matters.
When migrating from GPT‑5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl: "30m". Review cache boundaries and include billed cache writes in the calculation.
Fast mode is unavailable with EU data residency for Astra. If residency is a contractual requirement, plan around Standard processing and verify the account configuration before promising latency.
Steering cannot bypass controls
Store the original request, every mid-run change, its timestamp and the steps already completed. Otherwise a useful feature becomes an audit gap.
A new instruction such as “send it directly to the customer” must not bypass an approval gate that was designed for draft-only work. Steering may change the agent's direction; it must not override orchestrator policy.
OpenAI also notes that Astra can be more sensitive to instructions found in skills, AGENTS.md and other accessible files. Audit those instruction sources, remove conflicts and never give an untrusted document the same authority as system policy.
How I would evaluate Astra
Select 20 to 50 real tasks where Sol or another model currently fails intermittently: long complaints, contradictory contracts, multi-source incidents, cross-repository refactors or process audits.
Measure success, tool calls, tool wait time, retries, cache-hit rate, total input and output, human interventions and time to an approved result. Test failure paths too: a late result, duplicate callback, timeout, worker restart and a user correction introduced mid-run.
Only then decide whether Astra should replace Sol for that workflow branch. Cheaper models will remain the right default for most routine automation. Astra can win on a small number of expensive exceptions when its new agent controls reduce total work.
Sources: OpenAI GPT‑6 Astra model card, model guidance and migration notes, model and price comparison, and the YouTube signal Jirka Herník: New models at a fraction of the price.