GPT-6 Sol vs Luna vs Astra: API Prices, Professional Work, Factuality, Coding, Computer Use, Caching, and Alignment

GPT-6 comparison: start with evidence, not model names

OpenAI’s GPT-6 family now has three distinct members in the official source set for this article: GPT-6 Astra, GPT-6 Sol, and GPT-6 Luna. OpenAI positions Astra as its strongest overall GPT-6 model, while Sol and Luna are faster, lower-cost additions announced on September 22, 2026. That high-level positioning is important, but it is not enough to choose a production model. A founder evaluating support automation, an enterprise administrator setting ChatGPT Work defaults, a security team approving tool access, or a developer routing API traffic needs a more disciplined evidence model than “newest,” “cheapest,” or “best benchmark.”

The practical comparison begins with three layers of evidence. The first layer is documented specification: model IDs, token prices, context limits, supported endpoints, reasoning-effort options, modality support, tool support, and cache pricing from the official OpenAI model references and documentation. The second layer is vendor-reported evaluation evidence: launch benchmarks, internal factuality tests, coding evaluations, computer-use results, customer examples, and safety-system-card findings that OpenAI reports under defined conditions. The third layer is local deployment evidence: your own workload distribution, quality thresholds, latency and cost telemetry, cache-hit behavior, human-review burden, tool-call error rate, incident history, data-region requirements, and rollback plan.

This article uses that three-layer model throughout because each layer answers a different question. Documented specifications tell you what the model is listed as supporting and how list pricing is structured. Vendor-reported evaluations tell you what OpenAI observed in particular tests or customer examples, with caveats that those results may not reproduce in your workflow. Local deployment evidence tells you whether the model works for your actual users, prompts, files, tools, security policy, and approval process. Treating any one layer as sufficient is a common failure mode: specifications do not prove quality, benchmark wins do not prove fit, and a successful pilot without governance does not prove safe scale.

This article explains GPT-6 Astra pricing, including its 2.5x token premium over GPT-5.6 Sol and why cost per completed task can be lower when quality reduces retries. The GPT-6 Astra Pricing Explained: When the 2.5x Token Premium Can Cost Less Per Completed Task article is a focused companion for GPT-6 Astra Launch Analysis because the current comparison centers on Astra versus Sol/Luna API prices and work outcomes, so a focused Astra pricing analysis adds directly relevant context.

The family in one operational sentence

OpenAI describes GPT-6 Astra as the strongest overall model and Sol and Luna as lower-cost additions with different cost-capability balances. In practical terms, Astra is the default candidate for the hardest end-to-end work where quality, reasoning depth, and risk controls matter more than token price; Sol is a candidate for complex professional, coding, and agentic work where teams need a lower price than Astra but still want a stronger tier than Luna; Luna is the lowest-priced GPT-6 option in the official pricing set and is a candidate for focused, high-volume work after local evaluation confirms that quality and review cost remain acceptable.

That sentence deliberately avoids saying “use Luna for all cheap tasks,” “use Sol for all coding,” or “use Astra for all regulated work.” OpenAI’s sources do not establish universal routing rules. A low-cost model can become expensive if it requires more retries, longer prompts, higher reasoning effort, extra human review, or downstream correction. A stronger model can still be the wrong choice if its latency, cost, availability, or tool-policy constraints do not fit the workflow. A shared context window does not mean shared capability, shared latency, shared cost, or shared risk profile.

OpenAI’s model references list all three models with a 1,050,000-token context window, a maximum of 922,000 input tokens, and up to 128,000 output tokens. They accept text and image inputs and produce text output. Those large limits are useful for long documents, codebases, policy packages, discovery records, research bundles, and multi-turn agent state, but long context is not free. For requests above 272,000 input tokens, OpenAI documents 2x input and cache rates and 1.5x output rates for the full request. Any serious comparison must therefore account for prompt size, cache writes, cached reads, output and reasoning tokens, tool charges, retries, processing mode, and regional premiums where applicable.

The shortest safe read on API list prices

The official Standard API token prices per one million tokens are sharply different across the family. GPT-6 Luna is listed at $0.10 input, $0.01 cached input, $0.125 cache write, and $0.50 output. GPT-6 Sol is listed at $2 input, $0.20 cached input, $2.50 cache write, and $10 output. GPT-6 Astra is listed at $10 input, $1 cached input, $12.50 cache write, and $50 output. These are token prices, not total task prices, and they cannot be converted directly into guaranteed application savings.

OpenAI describes Sol and Luna as 50% cheaper than their GPT-5.6 promotional prices, but that statement is a comparison to a prior promotional price point, not a promise that your application bill will fall by 50%. Your bill depends on how much input you send, whether the prefix is cacheable, how many tokens are generated, how many reasoning tokens are used, whether a response is incomplete and retried, whether built-in or external tools are invoked, whether long-context multipliers apply, and whether you use Batch, Flex, Fast mode, or regional processing. For Sol and Luna, OpenAI documents a 10% premium for regional processing where available, with EU data residency available only with Standard processing. Batch and Flex are priced at 50% of Standard rates, while Fast mode is 2x applicable rates.

Prompt caching changes the calculation but does not eliminate it. OpenAI’s GPT-6 prompt-caching announcement says eligible cached input-token reads can receive discounts of up to 90%, and the API documentation specifies the GPT-5.6-and-later economics: cache writes cost 1.25 times the uncached input rate and cache reads cost 0.1 times that rate. A write is more expensive than ordinary input, so a one-off request is not automatically cheaper because it writes to cache. Reuse is the economic lever, and a session does not guarantee a cache hit.

Availability is not the same as capability

OpenAI’s Sol and Luna launch page states that Sol and Luna are available in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu users, and that Free and Go users can access Luna in the desktop application. The same launch source states that, at launch, the models are not yet available in Chat. OpenAI’s Help Center material on ChatGPT Work and Codex also emphasizes that availability depends on plan, workspace settings, role permissions, and rollout access. A workspace default does not grant a model to a user who lacks access through role or plan.

For developers, the API identifiers in the official source set are exact: gpt-6-sol and gpt-6-luna. The model references also document GPT-6 Astra as a model reference in the same family, but this article does not invent aliases, private deployment names, or implied availability beyond the cited OpenAI sources. ChatGPT plan allowances and API-key billing are separate systems; a model being available in ChatGPT Work or Codex does not mean its API usage is covered by a ChatGPT subscription, and API token pricing should not be used to infer plan usage behavior.

There is also a surface distinction that matters for administrators. Codex model selection, desktop Work/Codex pickers, ordinary Chat defaults, role permissions, file permissions, local/cloud permissions, browser or network controls, and workspace starting defaults are separate control points in OpenAI’s Help Center description. A governance policy that says “use Sol for coding” is incomplete unless it also says where Sol is available, who can select it, what tools it can use, whether code changes require human review, where logs are retained, and how rollback restores model, prompt, cache policy, tool configuration, and state handling together.

A compact fact/nonclaim matrix for Sol, Luna, and Astra

The matrix below separates what the official sources establish from what they do not establish. This is the starting point for the rest of the comparison, because it prevents a common category error: converting a source fact into a broader operational promise.

Topic	What the official sources establish	What the sources do not establish	Operational decision rule
Overall positioning	OpenAI positions Astra as the strongest overall GPT-6 model and Sol/Luna as lower-cost additions.	This does not prove Astra is best for every workflow or that Luna/Sol are sufficient for every lower-risk task.	Use positioning as an initial hypothesis, then test representative workloads with your own quality, cost, latency, and review metrics.
API prices	Standard per-million-token prices are documented for input, cached input, cache writes, and output for Luna, Sol, and Astra.	Token prices are not guaranteed total task costs or guaranteed savings versus older models.	Model the full request: uncached input, writes, reads, output, reasoning tokens, tools, retries, long-context multipliers, processing mode, and regional premiums.
Context length	All three model references list a 1,050,000-token context window, 922,000 maximum input tokens, and up to 128,000 output tokens.	Shared limits do not mean equivalent performance, latency, factuality, or suitability for long documents.	Evaluate long-context tasks separately, and include the documented multipliers above 272,000 input tokens.
Knowledge cutoff	OpenAI lists different published knowledge cutoffs: Sol April 20, 2026; Luna May 18, 2026; Astra April 30, 2026.	A later cutoff is not a quality ranking and does not guarantee current factual accuracy.	Use retrieval, dated sources, citations, and verification for current or consequential facts regardless of model.
Reasoning effort	Sol and Luna list none, low, medium, high, xhigh, and max; Astra lists low, medium, high, xhigh, and max. Sol and Luna default to medium.	The sources do not say every effort is appropriate for every task, cheaper, faster, or safer. Astra does not list none.	Validate model-specific settings in code and measure quality, latency, incomplete responses, and token usage at each effort level you plan to allow.
Benchmarks	OpenAI reports evaluation-specific results for professional work, coding, computer use, factuality, and alignment.	Benchmark scores are not universal production guarantees and should not be treated as incident-rate or reliability claims.	Use public benchmarks as inputs to a task-specific evaluation plan, not as deployment gates.
Prompt caching	OpenAI documents prefix-based caching with up to 90% discounts on eligible cached reads, 1.25x writes, 0.1x reads, and a 30-minute minimum eligibility window for the documented setting.	Caching is not semantic memory, data validation, authorization, prompt-injection defense, or a guaranteed hit. The 30-minute value is not a guaranteed physical-retention ceiling.	Keep stable prefixes stable only when semantically correct, isolate tenants, monitor cached tokens, and diagnose misses without assuming diagnostics prove full-request reuse.
Work and Codex access	Sol and Luna are described as available in ChatGPT Work and Codex for specified paid and organizational plans, with Luna desktop access for Free and Go users; launch sources say they are not ordinary Chat models at that time.	Availability is not universal plan access, not identical across surfaces, and not a substitute for role, workspace, or permission controls.	Document which surface, role, workspace, and model picker is in scope before changing defaults or user instructions.
Alignment and safety	OpenAI’s system-card material and appendices report results under defined challenge conditions and emphasize remaining failures, monitorability limits, and safeguards.	Challenge tests do not establish zero risk, typical-use failure rates, or permission for unattended high-impact actions.	Keep human approval, least privilege, sandboxing, monitoring, audit logging, and rollback for consequential operations regardless of selected model.

The three-layer evidence model for this comparison

A rigorous Sol-vs-Luna-vs-Astra decision should be organized as a sequence: first confirm documented capability, then examine vendor-reported evidence with caveats, then run local evaluations before adoption. This sequence is not bureaucratic overhead. It prevents teams from discovering too late that a model supports a capability in one API surface but not another, that a benchmark was run with a different effort setting than the production configuration, or that a lower token price is offset by more output, more retries, or more human correction.

Layer 1: documented specifications

Documented specifications are the hard boundary for implementation planning. The OpenAI model references state that the three GPT-6 models support the Responses API, Chat Completions, Batch, streaming, structured outputs, function calling, file search, image input, web search, and prompt caching. They do not support Assistants, Realtime, Live, fine-tuning, embeddings, speech, transcription, or legacy Completions endpoints according to the cited pages. The supported Responses tools listed in the model references include web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search.

Those endpoint and tool facts are operationally decisive. If an application is built on an unsupported endpoint, a model switch is not a one-line model-ID replacement. If a workflow depends on fine-tuning, embeddings, speech transcription, or legacy Completions, the cited GPT-6 model pages do not support that path. If an existing Chat Completions function-calling workflow targets Sol or Luna, the model references state that Chat Completions function calling is supported only when reasoning_effort is none; OpenAI recommends the Responses API for built-in tools and normal function-calling workflows. Astra does not list none as a reasoning effort, so copying Sol/Luna configuration into Astra routing code can fail or produce invalid assumptions.

The pricing specifications also belong in this first layer because they are documented, not inferred. However, a specification price is still only a component. Developers should log usage by uncached input tokens, cached input tokens, cache-write tokens, visible output tokens, reasoning tokens where exposed through usage accounting, tool calls, retries, service tier, processing mode, region, and input-size bracket. Finance teams should not approve a migration based on input-token price alone, because output on these models is more expensive than input, and reasoning tokens are billed as output tokens even when not visible.

Layer 2: vendor-reported evaluations

Vendor-reported evaluations are useful but bounded. OpenAI’s Sol and Luna launch article reports improvements in professional work, factuality, coding, computer use, and collaboration style, and includes examples such as Sol xhigh at 33.2% on AutomationBench for $0.27 per task, Sol max at 68.8% on DeepSWE 1.1, and Luna max at 66.6% on DeepSWE 1.1. Those figures should be read exactly as OpenAI-reported evaluation results under particular settings, not as universal production expectations.

OpenAI’s launch material explicitly notes that its evaluations may differ from production ChatGPT because of system prompts, tools, and other deployment differences. That caveat is not cosmetic. A coding benchmark run with a specific harness, repository set, effort level, and tool environment can diverge from a company’s monorepo, branch policy, test flakiness, dependency graph, permission model, and reviewer expectations. A factuality result from an internal evaluation can differ from a newsroom’s need for dated primary sources, a law firm’s citation requirements, or a medical educator’s safety review process.

Alignment and deception evaluations require even more conservative reading. OpenAI states that Sol and Luna improve on their GPT-5.6 counterparts in several alignment tests, including lower rates of misleading claims about coding work, but the launch notes and system-card material describe these as challenge evaluations, not estimates of typical-use failure rates. A lower rate in a stress test must not be converted into “the model will not misreport progress,” “the agent is safe to merge code,” or “monitoring can be removed.” Human approval remains mandatory for code deployment, external messages, legal commitments, purchases, account changes, destructive operations, and other consequential actions.

Layer 3: local deployment decisions

Local deployment evidence is where model selection becomes real. A team should evaluate Sol, Luna, and Astra on representative examples from the actual workflow, including routine cases, edge cases, adversarial prompts, long-context cases, tool-selection cases, tool-argument precision, incomplete-response handling, and handoff scenarios. The evaluation should record model ID, reasoning effort, reasoning mode where applicable, tools available, prompt version, cache state, token usage, latency, tool calls, failures, reviewer decision, and downstream correction cost.

OpenAI’s evaluation best-practices documentation recommends task-specific objectives, representative data, defined metrics, comparisons, and continuous evaluation. It also warns that academic or generic benchmarks alone are not substitutes for application-specific evaluations. For many LLM tasks, pairwise comparison, classification, or criterion-based scoring is more practical than open-ended judging, but LLM-as-judge systems can have position and verbosity bias and should be calibrated against human review. That means a model migration should have a named owner, a holdout set, a rubric, a pass/fail threshold, escalation rules, and a rollback plan before production traffic is shifted.

This GPT-5.6 family review compares Sol, Luna, and Terra across published pricing, benchmarks, and workload fit, supplying a historical baseline for understanding how the newer GPT-6 Sol, Luna, and Astra lineup changes model-selection decisions. The GPT-5.6 Complete Review August 2026: Sol vs Luna vs Terra Benchmarks, Pricing, and Real-World Performance Across Every Use Case article is a focused companion for GPT-5.6 Model Comparison because it is a direct GPT-5.6 family comparison, replacing the draft voice-feature article that only mentioned GPT-5.6 and Astra incidentally.

Initial model-by-model reading

The rest of this article will go deep on price, caching, Work and Codex availability, benchmark categories, factuality, coding, computer use, endpoints, tools, reasoning effort, and safety. Before that detail, it helps to define the editorial baseline for each model so the comparison does not collapse into a single leaderboard.

GPT-6 Astra: strongest overall, highest listed token price

OpenAI positions GPT-6 Astra as the strongest overall GPT-6 model and as the model for the most demanding work. In the official pricing set, Astra also has the highest listed Standard API prices: $10 input, $1 cached input, $12.50 cache write, and $50 output per one million tokens. This combination makes Astra a candidate for high-complexity tasks where errors are costly, reasoning depth matters, and the organization is prepared to pay for stronger model capability while maintaining controls.

Astra’s strongest-overall position does not authorize autonomous high-impact operation. OpenAI’s Astra launch and deployment-safety material emphasize constraints including remaining failures, evaluation awareness, monitorability limits, and the fact that absence of observed failures in an evaluation does not establish reliability across settings. In practice, Astra should still be wrapped with least-privilege tool access, source verification, sandboxing for code execution, audit logging, staged rollout, rollback, and human approval for consequential actions.

GPT-6 Sol: lower cost than Astra, positioned for complex work

GPT-6 Sol occupies the middle price tier in this comparison. Its Standard API prices are $2 input, $0.20 cached input, $2.50 cache write, and $10 output per one million tokens. OpenAI’s Sol and Luna launch positions Sol as one of the faster, more affordable members of the GPT-6 family, with reported improvements across professional work, factuality, coding, computer use, and collaboration style. Sol is therefore a serious candidate for complex coding, agentic, and professional workflows when Astra’s cost is not justified by local evaluation results.

Sol still requires workload-specific testing. A team might find that Sol at a higher effort level performs well enough for a code-review assistant but not for autonomous patch generation, or that it handles structured business analysis acceptably but struggles with long-context legal comparison without retrieval and human review. Because Sol and Luna support none reasoning effort but Astra does not list it, routing code should validate effort options per model instead of treating the GPT-6 family as configuration-compatible.

GPT-6 Luna: lowest listed price, not automatically lowest total cost

GPT-6 Luna has the lowest listed Standard API token prices in the official GPT-6 set used here: $0.10 input, $0.01 cached input, $0.125 cache write, and $0.50 output per one million tokens. That makes it attractive for high-volume workflows, classification-style tasks, extraction, first-pass drafting, structured transformations, triage, and other focused uses where local evaluation shows that quality remains within tolerance and human review does not erase the apparent savings.

Luna’s lower token price does not make it a safe default for every high-volume workflow. If a task requires more prompt scaffolding, more retrieval, more retries, more escalation to Sol or Astra, or more human correction, total cost and operational risk may rise. Low price is valuable only when measured against acceptable output quality, latency, cache reuse, failure handling, and downstream review effort. For sensitive, regulated, legal, medical, financial, employment, youth-safety, or security-sensitive uses, Luna should be evaluated with the same conservatism as the other models, including source verification and authorized human decision-making.

What the opening evidence already tells us

Even before the detailed matrices, several conclusions are safe within the official source boundary. First, Astra is the strongest overall model according to OpenAI, but it is also the highest-priced in the published Standard API token table. Second, Sol and Luna create a lower-cost path into the GPT-6 family, but their list prices and OpenAI’s 50% promotional-price comparison do not guarantee any particular workload savings. Third, all three models have large documented context windows, but long context can trigger documented multipliers and should not be treated as an invitation to send unnecessary data.

Fourth, prompt caching is economically important but frequently misunderstood. It reuses matching rendered prefixes; it does not retrieve semantic memories, validate facts, authorize data sharing, prevent prompt injection, or guarantee that a session will hit cache. Changing model, tools, tool ordering, structured-output schema, reasoning effort, verbosity, context management, compaction, or earlier input can affect reuse. On supported GPT-6 models, OpenAI documents an appended configuration_update path for changing reasoning effort while preserving the earlier cacheable prefix, whereas top-level reasoning changes can affect cache reuse.

Fifth, the product surface matters. Sol and Luna’s launch availability in ChatGPT Work and Codex is not the same as ordinary Chat availability, and it is not the same as API access or billing. Administrators should distinguish plan eligibility, rollout access, workspace defaults, user roles, model pickers, local/cloud permissions, file permissions, browser/network controls, and Codex behavior. Developers should distinguish Responses, Chat Completions constraints, Batch, streaming, structured outputs, tool support, and unsupported endpoints.

Sixth, safety and alignment evidence should be read as bounded evidence. OpenAI’s system-card material and launch caveats repeatedly warn that evaluations are defined-condition tests, not proofs of universal reliability. Monitorability remains an active research problem, safeguards can pause or stop legitimate work, and absence of observed failures does not prove reliability across settings. These caveats matter most when a model can use tools, write code, operate a computer, search the web, access files, call internal systems, or produce text that a human might publish, send, file, deploy, or rely on.

How to read the rest of the comparison

The upcoming sections compare Sol, Luna, and Astra across positioning, prices, cache economics, context limits, knowledge cutoffs, reasoning efforts, endpoint and tool support, professional-work claims, factuality, coding, computer use, Work and Codex availability, and alignment. Each comparison keeps three questions separate: what OpenAI documents, what OpenAI reports from evaluations or examples, and what your organization must decide locally. That separation is the difference between a useful model comparison and a misleading leaderboard.

When this article discusses benchmark figures, it attributes them to OpenAI and preserves the evaluation context rather than presenting them as universal rankings. When it discusses prices, it separates Standard token prices from cached reads, cache writes, long-context multipliers, regional processing, Batch, Flex, Fast mode, tool fees, reasoning tokens, and retries. When it discusses Work and Codex, it treats availability as plan-, role-, workspace-, surface-, and rollout-dependent. When it discusses safety, it assumes that human approval, access control, auditability, and rollback remain required for high-impact operations regardless of model.

The recommended operating posture is therefore conservative but not slow. Use Astra when the work is hard enough and important enough to justify top-tier capability after evaluation. Use Sol when local testing shows that it provides the needed quality for complex work at a lower cost than Astra. Use Luna when focused, high-volume tasks pass representative quality, safety, and review thresholds at its much lower token price. Route among them only with explicit policies that preserve access controls, tool boundaries, regional requirements, logging, human approval gates, and rollback behavior.

Specifications and cost: the numbers that shape routing decisions

OpenAI’s model-reference pages make one point unusually clear for the GPT-6 family: Sol, Luna, and Astra share several large-envelope specifications, but they do not share the same price, reasoning menu, knowledge cutoff, or availability profile. A shared context window can make the three models look interchangeable in a procurement spreadsheet; in production, the effective cost and risk profile changes with cache writes, cached reads, output tokens, reasoning tokens, long-context multipliers, processing mode, regional processing, tool calls, retries, and human-review burden.

The practical mistake to avoid is treating the per-million-token input price as the model’s “cost.” For the cited model pages, the Standard API prices split input into at least three categories: uncached input, cached input reads, and cache writes. Output has its own rate, and reasoning tokens are billed as output tokens under OpenAI’s reasoning documentation. When a request crosses OpenAI’s documented long-context threshold of more than 272,000 input tokens, the cited model references apply multipliers to the entire request: 2x input and cache rates, and 1.5x output rates. Those multipliers can erase a naïve assumption that a long prompt is cheap simply because it is mostly repeated or because the model has a large context window.

Standard API token prices, including cache write and cached read rates

The following table uses the exact Standard API list prices stated in the cited OpenAI model-reference pages. Prices are per one million tokens. These are token prices, not total task prices, and they do not include possible tool charges, retries, long-context multipliers, processing-mode changes, regional premiums, or application-side infrastructure and review costs.

Model	Uncached input	Cached input read	Cache write	Output	Operational reading
GPT-6 Luna	$0.10 / 1M tokens	$0.01 / 1M tokens	$0.125 / 1M tokens	$0.50 / 1M tokens	Lowest listed token price in this comparison, but still sensitive to output volume, reasoning effort, cache writes, tools, and retries.
GPT-6 Sol	$2.00 / 1M tokens	$0.20 / 1M tokens	$2.50 / 1M tokens	$10.00 / 1M tokens	Lower priced than Astra and positioned by OpenAI for more complex work than Luna, but materially more expensive than Luna at the token level.
GPT-6 Astra	$10.00 / 1M tokens	$1.00 / 1M tokens	$12.50 / 1M tokens	$50.00 / 1M tokens	Highest listed token price and positioned by OpenAI as the strongest overall GPT-6 model.

The cache prices are not optional footnotes. OpenAI’s prompt-caching documentation states that for GPT-5.6 and later, cache writes cost 1.25 times the uncached input rate and cached reads cost 0.1 times that rate. The model-reference pages express those same relationships in model-specific dollar amounts: Luna writes at $0.125 and reads at $0.01 per million tokens, Sol writes at $2.50 and reads at $0.20, and Astra writes at $12.50 and reads at $1.00. A single cache write is more expensive than processing the same tokens once as ordinary uncached input; caching becomes economically useful only when reuse, output behavior, long-context handling, and workflow design justify the write.

This playbook describes prompt caching strategies for reducing LLM API costs, including caching architecture and cost-reduction tactics across production model use. The Prompt Caching Strategies: 89% Cost Reduction Playbook article is a focused companion for Prompt Caching Economics because the marker is specifically about caching economics, and this target directly addresses prompt caching as a cost-control mechanism.

Long-context pricing: the 272,000-token threshold changes the whole request

All three cited model pages document the same long-context pricing rule: for requests above 272,000 input tokens, input and cache rates are multiplied by 2x and output rates are multiplied by 1.5x for the full request. This is not a marginal charge on only the tokens above the threshold in the source notes; it applies to the full request. Developers building retrieval-heavy, codebase-wide, legal-review, e-discovery, or knowledge-base workflows should therefore model a discontinuity around that threshold rather than smoothing costs across a linear token curve.

Model	Uncached input above 272k input tokens	Cached input read above 272k input tokens	Cache write above 272k input tokens	Output above 272k input tokens
GPT-6 Luna	$0.20 / 1M tokens	$0.02 / 1M tokens	$0.25 / 1M tokens	$0.75 / 1M tokens
GPT-6 Sol	$4.00 / 1M tokens	$0.40 / 1M tokens	$5.00 / 1M tokens	$15.00 / 1M tokens
GPT-6 Astra	$20.00 / 1M tokens	$2.00 / 1M tokens	$25.00 / 1M tokens	$75.00 / 1M tokens

A long-context request can be correct and still uneconomical. For example, a code-review agent that repeatedly sends an entire monorepo, a full dependency graph, tool definitions, long conversation history, and prior generated patches may benefit from the documented 1,050,000-token context window, but it should not assume that the window is a recommendation to fill. The safer design is to separate stable, cacheable prefixes from task-specific deltas; retain tool schemas and ordering where semantically correct; use retrieval or narrowing when possible; and measure cost against accepted outputs, not against raw token price alone.

Batch, Flex, Fast, and regional processing

The cited model-reference pages state that Batch and Flex are priced at 50% of Standard rates, while Fast mode is priced at 2x applicable rates. This creates a direct tradeoff for workload design: asynchronous or less time-sensitive jobs may qualify for lower token rates under Batch or Flex, while latency-sensitive user-facing work may cost more under Fast. The sources do not establish that every account, region, task, or compliance configuration can use every processing mode; teams should validate availability and policy fit before routing production traffic.

Processing choice	Price effect stated in model references	Good fit to evaluate	Operational warning
Standard	Baseline listed rates	Interactive production traffic where standard processing meets latency, policy, and availability needs.	Baseline price still excludes tool fees, retries, long-context multipliers, and application operations.
Batch	50% of Standard rates	Offline evaluation, document preprocessing, large non-urgent classification, or queued analysis where delayed completion is acceptable.	Do not use lower price as a reason to weaken data controls, approvals, tenant isolation, or output review.
Flex	50% of Standard rates	Elastic workloads that can tolerate the relevant processing characteristics and are not on a tight interactive path.	Availability and suitability may vary; verify against the model documentation and your account controls.
Fast	2x applicable rates	Latency-sensitive tasks where faster response is worth the premium after measuring accepted-output cost.	Fast mode can materially change effective task cost, especially when paired with high effort, long contexts, or many retries.
Regional processing	10% premium where available for Sol and Luna	Workloads that require or prefer eligible regional processing and can operate within the documented constraints.	EU data residency for Sol and Luna is available only with Standard processing in the cited notes; caches are not shared across regional processing boundaries.

Regional processing is a governance feature before it is a price feature. The source notes state that regional processing adds a 10% premium where available for Sol and Luna and that EU data residency for Sol and Luna is available only with Standard processing. Teams should not route a regulated workload to a cheaper or faster tier unless that tier preserves the organization’s data-region rule, retention posture, audit logging, and approval policy. Cache reuse also cannot be assumed across regional processing boundaries, so regional routing can affect both compliance and cache-hit economics.

Context window, input ceiling, and output ceiling

The three cited model-reference pages document a shared 1,050,000-token context window, a maximum of 922,000 input tokens, and up to 128,000 output tokens. These limits are capacity boundaries, not quality promises. A model can accept a very large context and still miss a relevant fact, over-weight stale instructions, produce an incomplete answer, incur higher cost, or require a human to verify the result against source evidence.

Specification	GPT-6 Luna	GPT-6 Sol	GPT-6 Astra	What it does not prove
Context window	1,050,000 tokens	1,050,000 tokens	1,050,000 tokens	Does not prove equal reasoning quality, equal retrieval accuracy, equal latency, equal cost, or equal suitability for long documents.
Maximum input	922,000 tokens	922,000 tokens	922,000 tokens	Does not make full-context prompting the right architecture; long-context multipliers may apply above 272,000 input tokens.
Maximum output	128,000 tokens	128,000 tokens	128,000 tokens	Does not mean visible answer length will be 128,000 tokens; reasoning tokens count against output and context limits even when not visible.
Input modalities	Text and image	Text and image	Text and image	Does not establish domain accuracy for every visual, legal, medical, financial, or safety-critical interpretation.
Output modality	Text	Text	Text	Does not imply native audio, speech, transcription, embeddings, fine-tuning, or realtime support on the cited pages.

For application engineers, the maximum output number has a hidden implementation consequence. OpenAI’s reasoning documentation states that reasoning tokens are billed as output tokens and count against output and context limits, even though raw chain-of-thought is not exposed. If `max_output_tokens` is too low for the selected reasoning effort and task, a response can end as `incomplete`, potentially before any visible answer is produced. Production clients should handle incomplete status explicitly with a safe retry, escalation, or user-facing explanation rather than treating the response as accepted work.

Knowledge cutoffs: useful metadata, not freshness guarantees

The model-reference pages list different knowledge cutoffs: GPT-6 Luna is May 18, 2026, GPT-6 Sol is April 20, 2026, and GPT-6 Astra is April 30, 2026. A later cutoff is not a ranking of model quality, and it does not remove the need for retrieval, dated sources, or human verification in workflows that depend on current facts. A May cutoff may matter for some historical questions and not at all for tasks that require today’s filings, current package versions, current pricing, new regulations, recent vulnerabilities, or live organizational data.

Model	Published knowledge cutoff	Safe operational interpretation
GPT-6 Luna	May 18, 2026	Useful for estimating training recency, but current and high-stakes facts still need retrieval, source dates, and verification.
GPT-6 Sol	April 20, 2026	Does not make Sol less suitable by itself; choose based on task evals, price, reasoning behavior, tools, and review burden.
GPT-6 Astra	April 30, 2026	OpenAI positions Astra as strongest overall despite not having the latest listed cutoff among the three.

A procurement or engineering team should never route legal research, compliance monitoring, security triage, medical education, market analysis, or customer communications solely on a cutoff date. The better rule is to classify the task: if the answer depends on recent or changing facts, connect the workflow to approved retrieval sources, record source dates, preserve citations, and require qualified review where the decision is consequential. The model’s cutoff tells you what not to assume; it does not tell you what is true today.

Reasoning effort and mode support

OpenAI’s reasoning documentation states that GPT-6 Sol and Luna default to medium reasoning effort, and the cited model-reference pages list the available effort values. Sol and Luna support `none`, `low`, `medium`, `high`, `xhigh`, and `max`. Astra supports `low`, `medium`, `high`, `xhigh`, and `max`; `none` is not listed for Astra. Routing code should validate reasoning settings per model instead of copying one configuration across the family.

Model	Listed reasoning efforts	Default noted in source findings	Implementation consequence
GPT-6 Luna	none, low, medium, high, xhigh, max	medium	Can be tested across a wide effort range, but higher effort can increase output-token billing and latency.
GPT-6 Sol	none, low, medium, high, xhigh, max	medium	Useful for staged evaluation of complex coding or agentic workflows, with output-token and incomplete-response handling included.
GPT-6 Astra	low, medium, high, xhigh, max	Not stated in the supplied findings as a family-wide default for Astra	Do not send none to Astra unless the current model documentation later lists it; validate before request construction.

Reasoning effort is not a free quality knob. OpenAI states that GPT-5.6 and GPT-6 models support `standard` and `pro` reasoning modes, that mode and effort are independent, and that pro mode performs more model work, increases token usage and latency, and bills those tokens at the selected model’s standard rates. A team comparing Luna at high effort with Sol at medium effort or Astra at low effort must compare accepted task outcomes, total output tokens, incomplete responses, and review time, not just model names.

On supported GPT-6 models, OpenAI’s prompt-caching guidance says an appended configuration_update can change reasoning effort during a conversation while preserving the earlier cacheable prefix. The same guidance warns that changing top-level reasoning settings can affect cache reuse. In practice, a workflow that uses caching should place stable developer instructions, tool definitions, schemas, and durable context before volatile task instructions, then append effort changes only where supported and semantically correct.

Endpoints and surfaces: Responses is the safest default for tool-rich work

The cited model-reference pages state that GPT-6 Luna, Sol, and Astra support Responses, Chat Completions, Batch, streaming, structured outputs, function calling, file search, image input, web search, and prompt caching. The same pages state that they do not support Assistants, Realtime, Live, fine-tuning, embeddings, speech, transcription, or legacy Completions. These endpoint facts matter because an unsupported endpoint is not a migration target, even if a previous model or application path used it.

Capability or endpoint	Luna	Sol	Astra	Planning note
Responses API	Supported	Supported	Supported	OpenAI recommends Responses for reasoning models and for built-in tools and normal function-calling workflows.
Chat Completions	Supported	Supported	Supported	For Sol and Luna, Chat Completions function calling is documented only when reasoning_effort is none.
Batch	Supported	Supported	Supported	Batch pricing is documented at 50% of Standard rates, but suitability depends on workload and policy needs.
Streaming	Supported	Supported	Supported	Streaming can improve perceived responsiveness but does not reduce the need to detect incomplete or unsafe outputs.
Structured outputs	Supported	Supported	Supported	Schema changes can affect prompt-cache reuse; keep schemas stable where operationally correct.
Prompt caching	Supported	Supported	Supported	A session does not guarantee a cache hit; actual reuse is measured through cached-token usage fields.
Assistants	Not supported on cited model page	Not supported on cited model page	Not supported on cited model page	Do not plan a new GPT-6 Sol/Luna/Astra integration around the Assistants endpoint based on these sources.
Realtime / Live	Not supported on cited model page	Not supported on cited model page	Not supported on cited model page	Do not infer voice, live session, or realtime behavior from text-and-image model support.
Fine-tuning	Not supported on cited model page	Not supported on cited model page	Not supported on cited model page	Adapt through prompts, retrieval, tools, evaluation, and routing unless the current docs later state otherwise.
Embeddings, speech, transcription, legacy Completions	Not supported on cited model page	Not supported on cited model page	Not supported on cited model page	Use models and endpoints documented for those modalities rather than assuming GPT-6 text models cover them.

Function calling deserves a special migration warning. The source notes state that Sol and Luna support Chat Completions function calling only when reasoning_effort is none, while OpenAI recommends the Responses API for built-in tools and normal function calling. If an existing Chat Completions integration depends on function calls and also wants non-none reasoning effort, the safe path is not to silently drop the effort value or the function interface; it is to test a Responses-based implementation with the same authorization, logging, error handling, and human-approval rules.

Supported Responses tools and what tool support does not authorize

The cited model pages list the supported Responses tools for these models as web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search. Tool availability in documentation does not mean every workspace, account, application, or user role can use every tool. It also does not mean the model may take external action without authorization. For security teams, the correct interpretation is that these tools expand possible workflows and therefore expand the policy surface that must be controlled.

Tool category listed in model references	Typical use to evaluate	Required control before production use
Web search	Retrieving current public information, source dates, and external references.	Source-quality policy, citation capture, prompt-injection defenses, and human review for consequential claims.
File search	Searching approved internal or uploaded documents.	Access controls, tenant boundaries, document classification, and audit logging.
Image generation	Creating visual assets or mockups where permitted.	Brand, copyright, consent, advertising, youth-safety, and publication review rules.
Code interpreter	Data analysis, transformations, and reproducible calculations in a controlled environment.	Data-minimization rules, review of generated artifacts, and controls on regulated or personal data.
Hosted shell	Command execution in a controlled environment for development or automation tasks.	Sandboxing, no secrets in prompts, least privilege, egress controls, and destructive-command approvals.
Apply patch	Generating or applying code changes in supported coding workflows.	Branch protection, test execution, code review, rollback, and human approval before merge or deployment.
Skills	Reusable task-specific capabilities exposed to the model.	Versioning, permission review, logging, and regression tests for each skill.
Computer use	Interacting with graphical or browser-based environments under controlled conditions.	Strict sandboxing, allowlists, monitoring, and mandatory approval before submission, purchase, booking, deletion, publication, or account changes.
MCP	Connecting to approved tool servers and enterprise systems.	Server trust review, scoped credentials outside prompts, per-tool authorization, and incident logging.
Tool search	Discovering available tools in supported environments.	Tool inventory governance, role-based availability, and prevention of unapproved tool escalation.

Tool support is not the same as action authority. A model that can use computer-use or shell tooling still requires application-level policies that block unauthorized purchases, submissions, access changes, destructive commands, publication, external messaging, legal commitments, and regulated decisions until an authorized person approves. This is especially important when moving from a text-only assistant to an agentic workflow because the same model output can become more consequential once connected to tools.

Work and Codex availability is separate from API capability

OpenAI’s Sol and Luna launch article states that Sol and Luna are available in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu users; Free and Go users can access Luna in the desktop application; and, at launch, the models are not yet available in Chat. The Help Center source further states that availability depends on plan, workspace settings, role permissions, and rollout access. This means a user seeing a model in one surface does not prove API entitlement, and an API model ID does not prove availability in ordinary Chat or a particular Work/Codex workspace.

Surface	Source-grounded availability note	Administrative warning
API	Model identifiers include gpt-6-sol and gpt-6-luna; Astra has its cited model-reference page.	API billing and ChatGPT plan usage are separate systems; do not infer one from the other.
ChatGPT Work	Sol and Luna are available in Work for specified paid and organizational plans according to the launch source and Help Center notes.	Workspace defaults, role permissions, and rollout access can limit what a particular user can select.
Codex	Sol and Luna are available in Codex for specified paid and organizational plans according to OpenAI’s launch and Help Center information.	Codex preserves a manually selected model; desktop Work/Codex picker behavior is separate from ordinary Chat defaults.
Ordinary Chat	The launch and Help Center notes state that Sol and Luna are not available in ordinary Chat conversations at the cited time.	Do not write training or support materials that tell users to select Sol or Luna in ordinary Chat unless current OpenAI documentation has changed.
Desktop application	OpenAI states that Free and Go users can access Luna in the desktop application.	Desktop access does not imply web, mobile, Work, Codex, or API availability for the same user.

For enterprise administrators, the key governance rule is that a starting default does not grant access to a model unavailable to a user’s role. Workspace owners and administrators may configure starting model, reasoning level, speed, Fast Mode availability, and new-chat behavior for Work and Codex, but those controls remain separate from browser controls, network controls, file permissions, local permissions, cloud permissions, and API-key billing. Model choice should be documented as part of a workflow policy, not treated as a universal user preference.

Prompt caching mechanics that affect cost comparisons

OpenAI’s prompt-caching documentation says prompt caching is enabled by default for supported models and reuses an unchanged rendered prefix. It can include developer messages, tool definitions, conversation history, text, images, documents, and supported audio, but the cache stores key-value tensors rather than prompt tokens. This distinction matters because prompt caching is not semantic memory, not a fact checker, not an authorization mechanism, and not a guarantee that data may be reused across users, organizations, regions, or purposes.

For GPT-5.6 and later, OpenAI documents a minimum cacheable visible prefix of 1,024 tokens. Shared prefixes remain eligible for reuse within a 30-minute window under the documented prompt_cache_options.ttl value of 30m, which the source notes describe as a minimum eligibility period after the latest write or reuse. That 30-minute value should not be described as a guaranteed physical-retention ceiling. Organizations with retention, privacy, or Zero Data Retention obligations must review the current OpenAI documentation and their own contract and policy settings rather than assuming cache lifetime from a simplified summary.

Cache misses can result from model changes, tools, tool ordering, structured output schema changes, reasoning effort, verbosity, context management, compaction, service tier, cache key differences, or earlier input changes. A session does not guarantee a cache hit, and diagnostics that classify a request as cache_hit do not prove the entire current prompt was served from cache. Actual reuse should be measured through usage fields such as cached input-token details and reconciled with request-level cost accounting.

{
  "cost_accounting_fields_to_capture": [
    "model",
    "service_tier_or_processing_mode",
    "regional_processing_flag",
    "input_tokens_uncached",
    "input_tokens_cached_read",
    "input_tokens_cache_write",
    "output_tokens_visible",
    "output_tokens_reasoning_or_hidden_if_reported",
    "long_context_multiplier_applied",
    "tool_calls_and_tool_charges",
    "retries",
    "response_status",
    "incomplete_reason_if_any",
    "human_review_required",
    "accepted_output"
  ]
}

This sample accounting shape is a recommendation, not an OpenAI API schema. Its purpose is to prevent a common internal reporting error: counting only uncached input and visible output while ignoring cache writes, hidden reasoning tokens, long-context multipliers, tools, retries, and rejected outputs. A workflow with a low per-token model can still be expensive if it produces long rejected answers, repeatedly misses cache, or triggers high-effort retries.

A worked cost-comparison pattern for architects

Use a task-level formula rather than a model-name shortcut. For each candidate model and configuration, calculate uncached input, cache writes, cached reads, output tokens, reasoning tokens, long-context multipliers, processing mode, regional premium, tool charges, retries, and rejected responses. Then divide by accepted work units: approved summaries, merged patches, correct classifications, resolved tickets, reviewed documents, or another business-specific outcome. OpenAI’s public list prices are the starting variables; your application’s token shape and acceptance rate determine the useful cost.

Task cost estimate =
  uncached_input_tokens * uncached_input_rate
+ cached_read_tokens * cached_input_rate
+ cache_write_tokens * cache_write_rate
+ output_tokens_including_reasoning * output_rate
+ applicable_tool_charges
+ retry_costs
then apply:
  long_context_multiplier where documented
  processing_mode_multiplier where applicable
  regional_processing_premium where applicable
and finally normalize by:
  accepted_outputs, not raw responses

This formula is intentionally conservative. It prevents two bad decisions: declaring Luna the winner because it has the lowest listed token price, or declaring Astra the winner because OpenAI positions it as strongest overall. Luna may be best for high-volume focused work that passes local quality gates; Sol may be more economical for complex coding or agentic tasks if it reduces retries and review time; Astra may be justified where its stronger overall capability changes acceptance rates or risk. None of those outcomes is established by the price table alone.

What the specifications establish

The specifications establish the official model identifiers, published token-price categories, context and output limits, listed knowledge cutoffs, supported reasoning effort values, endpoint support, tool support, and stated processing-mode price multipliers on the cited pages. They also establish that Astra remains OpenAI’s strongest overall GPT-6 model, while Sol and Luna are lower-cost additions with different cost-capability balances. For an engineering team, that is enough to build a candidate routing matrix and a cost model for evaluation.

The specifications also establish several constraints that should stop unsupported migrations. These models are not documented on the cited pages as supporting Assistants, Realtime, Live, fine-tuning, embeddings, speech, transcription, or legacy Completions. Sol and Luna’s Chat Completions function calling is limited in the source notes to reasoning_effort: none. Astra does not list none reasoning effort. If an existing production workflow requires one of those unsupported surfaces or configuration combinations, the migration plan must change the architecture, not merely replace a model string.

The pricing tables establish a disciplined way to compare requests. They show that cached reads are cheaper than uncached input, cache writes are more expensive than uncached input, long contexts can multiply the whole request, Batch and Flex can reduce rates where suitable, Fast can increase rates, and regional processing can add a premium for Sol and Luna where available. That evidence supports FinOps modeling; it does not prove actual workload savings.

What the specifications do not establish

The specifications do not establish latency for your workload. Fast mode has a documented price multiplier, but the supplied sources do not provide universal response-time guarantees for every account, region, prompt length, reasoning effort, tool chain, or traffic pattern. Measure latency with representative inputs and include p95 or p99 behavior, incomplete responses, retries, and tool execution time before changing service-level commitments.

The specifications do not establish reliability or safety for autonomous operation. OpenAI’s Deployment Safety materials emphasize that evaluation results are produced under defined conditions, that remaining failures exist, that monitorability has limits, and that absence of observed failures does not establish reliability across settings. A model with strong benchmark results still needs sandboxing, least privilege, audit logs, approval gates, rollback, incident response, and qualified human review for consequential actions.

The specifications do not establish factual accuracy for your domain. Knowledge cutoffs, context size, and tool support are helpful, but factuality in a legal, medical, financial, educational, security, or enterprise context depends on source quality, retrieval design, prompt instructions, review workflow, and the consequences of error. Current facts require dated sources and verification, and regulated or high-impact uses require domain-appropriate oversight.

The specifications do not establish plan access for a given user. Work and Codex availability depends on plan, rollout, workspace settings, role permissions, and administrator configuration. API access, ChatGPT plan usage, desktop application access, and ordinary Chat availability are separate surfaces. A support article, procurement memo, or training guide should state the surface being discussed rather than saying that a model is simply “available.”

The specifications do not establish cache hit rates. OpenAI says GPT-6 prompt caching provides higher hit rates by default and supports additional controls such as dashboards, diagnostics, explicit breakpoints, prewarming, and append-only patterns, but a session does not guarantee a hit. Customer examples reported by OpenAI, such as GitHub’s attributed reduction in prompt tokens requiring fresh processing against its previous baseline, are customer-specific examples rather than promises for another architecture.

The specifications do not establish application-specific fit. Public model pages and launch articles can identify candidate models and constraints, but they cannot tell whether your coding agent produces mergeable patches, whether your research assistant cites the right sources, whether your computer-use workflow avoids unsafe clicks, whether your support bot reduces escalations without creating compliance risk, or whether your staff will accept the outputs. Those questions require representative evaluation and staged deployment.

Recommended specification-led routing checklist

The following checklist is a recommendation for teams comparing Sol, Luna, and Astra. It is not an OpenAI policy, and it should be adapted to the organization’s security, privacy, legal, and operational controls.

1. Record the exact model ID and surface being tested: API, Work, Codex, desktop application, or another approved environment.
2. Validate endpoint support before implementation; do not assume Assistants, Realtime, Live, fine-tuning, embeddings, speech, transcription, or legacy Completions support.
3. Validate reasoning settings per model; do not send Astra a none effort value based on Sol or Luna behavior.
4. Use Responses for built-in tools and general function-calling workflows unless a tested and documented Chat Completions path meets the model’s constraints.
5. Build a per-task cost model that separates uncached input, cache writes, cached reads, output, reasoning tokens, tools, retries, long-context multipliers, processing mode, and regional premiums.
6. Measure accepted-output cost, not just raw response cost.
7. Test at realistic context sizes, including any prompts near or above the 272,000-input-token threshold.
8. Keep stable prefixes stable only when semantically correct; do not preserve obsolete instructions merely to protect a cache hit.
9. Require human approval for external messages, code merges, deployments, permission changes, purchases, payments, bookings, legal commitments, publication, destructive actions, and regulated decisions.
10. Document rollback as a bundle: model, prompt, cache policy, tools, permissions, state handling, and monitoring must roll back together.

The strongest conclusion from the specification layer is not that one model “wins.” It is that GPT-6 model selection is now a multi-variable engineering decision. Astra has OpenAI’s strongest-overall positioning and the highest listed token price; Sol offers a lower-cost tier for more complex work than Luna; Luna has the lowest listed token price and broad appeal for focused high-volume tasks. The correct production choice is the one that passes local evaluation at an acceptable total cost and risk level while preserving data governance, tool controls, and human accountability.

Benchmarks, factuality, collaboration style, and safety evidence: what can be compared without overclaiming

OpenAI’s public evidence for GPT-6 Sol, GPT-6 Luna, and GPT-6 Astra spans launch benchmarks, model-reference specifications, prompt-caching documentation, and the GPT-6 Astra system card with a Sol/Luna appendix. The comparison is useful only if each number keeps its original scope: a score belongs to a dataset, an effort setting, a tool environment, a prompting configuration, and a measurement method. A public benchmark can justify a local test, but it cannot by itself authorize production migration, unattended agents, or high-impact action.

For this section, the practical reading is simple: Astra remains OpenAI’s strongest overall GPT-6 model, while Sol and Luna are lower-cost members with different capability/cost balances. OpenAI reports improvements for Sol and Luna across professional work, factuality, coding, computer use, and collaboration style, but the same source notes that evaluations may differ from production ChatGPT because of system prompts, tools, and other deployment differences. That caveat matters for developers comparing API behavior, administrators managing ChatGPT Work and Codex, and security teams approving tool-using agents.

Challenge evaluations deserve special care. OpenAI’s deployment-safety materials describe safety, robustness, hallucination, alignment, monitorability, preparedness, and safeguard results under defined evaluation conditions. They also emphasize remaining failures, evaluation awareness, and limits of monitorability. The absence of observed failures in a test should not be converted into “safe for autonomous operation,” and alignment challenge-set percentages should not be treated as typical-use incident rates.

Benchmark comparison matrix: read the labels before the scores

Evidence category	What OpenAI reports or positions	Operational interpretation	Important caveat
Overall model positioning	OpenAI positions GPT-6 Astra as the strongest overall model; Sol and Luna are lower-cost additions.	Use Astra as the escalation candidate for the hardest end-to-end tasks, not as a universal default for every request.	Strongest overall does not mean lowest cost, lowest latency, or best fit for every workflow.
AutomationBench	OpenAI reports Sol at xhigh effort reaching 33.2% on AutomationBench at $0.27 per task.	Useful evidence for agentic automation testing, especially when cost per task matters.	The task price and score are evaluation-specific; they are not a guarantee for a company’s automation queue.
DeepSWE 1.1	OpenAI reports Sol max at 68.8% and Luna max at 66.6% on DeepSWE 1.1.	Both Sol and Luna deserve local evaluation for software-engineering workloads instead of assuming Luna is only for trivial tasks.	The max-effort setting, benchmark harness, repository mix, and grading method must be preserved in interpretation.
FrontierCode	OpenAI includes FrontierCode among the coding and agentic work evaluations used in its GPT-6 launch evidence.	Treat it as directional coding evidence that should inform a repository-specific regression suite.	Public or vendor-reported coding benchmarks do not establish mergeability, security correctness, maintainability, or project-specific style compliance.
Agents’ Last Exam	OpenAI includes Agents’ Last Exam in the family’s professional and agentic evaluation evidence.	Use it as a signal for multi-step agent capability under test conditions.	It is not a substitute for testing tool permissions, handoffs, approvals, and failure recovery in the target environment.
OSWorld and computer use	OpenAI reports computer-use evidence for the GPT-6 family, including OSWorld-style evaluation categories.	Relevant for browser, desktop, or UI-driving workflows where the model must interpret state and sequence actions.	Computer-use scores do not authorize real account changes, purchases, submissions, deletions, or publication without human approval and audit controls.
Factuality	OpenAI reports factuality improvements for Sol and Luna compared with prior counterparts.	Use stronger factuality as a reason to test research and summarization workflows.	A model’s knowledge cutoff is not a freshness guarantee, and factuality evaluations do not remove the need for retrieval, citations, and verification.
Alignment and deception challenge tests	OpenAI states Sol and Luna improve on GPT-5.6 counterparts in several alignment tests, including lower rates of misleading claims about coding work.	Use the result to design local checks for task-status honesty, evidence requirements, and refusal behavior.	Challenge tests are not incident-rate estimates and do not prove agents will never misreport work.

This matrix intentionally separates reported evidence from operational permission. A benchmark can make a model worth evaluating, but it does not decide whether the model can access production systems, write to a repository, email a customer, submit a legal filing, change a permission, or make a regulated recommendation. The routing decision still needs local tests, least-privilege tools, auditable state, rollback, and human approval for consequential operations.

This article provides prompts and a measurement framework for evaluating coding-agent research productivity through experiments, task success, human interventions, and cost. The 25 ChatGPT-5.5 Prompts for Measuring Coding-Agent Research Productivity: Experiments, Task Success, Human Interventions, and Cost article is a focused companion for Coding Agent Benchmarks because the current article discusses coding performance and agentic work, so a target about measuring coding-agent productivity and cost is semantically precise.

AutomationBench and Agents’ Last Exam: agentic work needs environment matching

AutomationBench and Agents’ Last Exam are most relevant to teams evaluating multi-step professional work: planning, tool selection, state tracking, correction after failure, and completion of a measurable objective. OpenAI’s reported Sol result on AutomationBench—33.2% at xhigh effort for $0.27 per task—should be read as a bounded evaluation result, not as an estimate of what an internal procurement workflow, help-desk triage agent, or build-release assistant will cost.

The first environment caveat is tool availability. A model tested with one set of tools can behave differently when the production application exposes file search, code interpreter, hosted shell, web search, computer use, MCP, tool search, or custom functions. Tool definitions, tool ordering, schemas, and permissions affect both task performance and prompt-cache reuse. If a benchmark score looks promising, the next step is not direct migration; it is a local harness that records model ID, reasoning effort, mode, tool set, tool arguments, token usage, cache state, latency, errors, and human-review outcome.

The second caveat is action authority. Agentic evaluations often reward completing a task; production governance must also reward stopping safely. A model that can navigate a task may still need to ask for approval before sending a message, buying a service, changing a record, merging code, deleting a file, altering access, or publishing content. For enterprise administrators, the safe default is to separate “plan,” “prepare,” and “propose” privileges from “execute” privileges until the workflow has passed representative evaluation and security review.

Coding evidence: FrontierCode, DeepSWE, and the difference between passing a benchmark and shipping software

OpenAI’s DeepSWE 1.1 figures are among the most concrete model-to-model signals in the Sol and Luna launch evidence: Sol at max effort is reported at 68.8%, while Luna at max effort is reported at 66.6%. The close reported values are operationally interesting because they challenge the lazy assumption that the lower-priced Luna should be excluded from coding workflows. They do not, however, prove that Luna is the right model for a security-sensitive migration, a difficult refactor, or an unfamiliar monorepo.

FrontierCode and DeepSWE-style evaluations should be translated into local software-engineering tests. A practical local suite includes failing tests to fix, small feature requests, dependency updates, documentation-driven changes, code-review comments, security bug reproductions, and rollback tasks. Each task should be scored on correctness, test pass rate, diff minimality, maintainability, dependency safety, style compliance, explanation quality, and whether the agent truthfully reports what it did and did not verify.

OpenAI’s alignment notes about lower rates of misleading claims about coding work are especially relevant for Codex-style workflows. The operational risk is not only “bad code”; it is a model claiming that tests passed, a migration was completed, or a file was changed when the evidence does not support that claim. A safer coding workflow requires the agent to cite exact commands run, summarize test output, identify unrun tests, mark assumptions, and request human review before merge or deployment.

Recommended coding-agent rule: Treat every model-generated patch as untrusted until the repository’s own tests, linters, security checks, code owners, and deployment gates have evaluated it. A stronger benchmark result can raise a model’s priority in the evaluation queue, but it must not bypass review.

For Sol and Luna specifically, developers must also avoid copying one configuration across the family without validation. The cited model references list different reasoning-effort support across models: Sol and Luna support none, low, medium, high, xhigh, and max, while Astra does not list none. OpenAI also notes that Sol and Luna support Chat Completions function calling only when reasoning_effort is none; for built-in tools and normal function-calling workflows, the Responses API is the safer architectural default.

OSWorld and computer use: UI control is a governance problem, not just a model score

Computer-use evaluations such as OSWorld-style tasks matter because many valuable workflows happen in graphical interfaces, browsers, dashboards, and SaaS tools rather than clean APIs. A model that can interpret screen state, follow instructions, and sequence UI actions may help with repetitive administrative work. But the same capability can also amplify mistakes if the agent has broad permissions, weak supervision, or access to sensitive accounts.

The key distinction is between observation and execution. Reading a page, extracting non-sensitive information, or drafting a proposed action is lower risk than clicking a button that changes a customer record, submits a government form, sends a legal notice, approves an invoice, modifies a security group, or deletes data. Computer-use governance must define which actions are read-only, which are draft-only, which require step-up approval, and which are prohibited for agent execution.

This article explains how to lock down Codex browser and computer-use capabilities with managed requirements.toml policies for enterprise control. The How to Lock Down Codex Browser and Computer Use with Managed requirements.toml Policies article is a focused companion for Computer Use Governance because the marker emphasizes governance rather than basic setup, and this target is specifically about policy controls for browser and computer use.

OpenAI’s GPT-6 Astra materials also warn that safeguards can pause or stop legitimate work and that monitoring cannot replace alignment. That is an important operational warning for computer-use systems. A safeguard that interrupts a workflow may be correct, overcautious, or triggered by ambiguous context; the application needs resumable state, user-visible explanations where appropriate, escalation paths, and logs sufficient for review. Conversely, a monitor that fails to catch a bad action cannot be treated as evidence that the action was safe.

A conservative computer-use rollout should start with shadow mode, then supervised mode, then narrow canaries. In shadow mode, the model proposes UI actions but does not execute them. In supervised mode, a human approves each consequential click or submission. In canary mode, the model receives limited authority for reversible, low-impact actions with audit logging and rollback. High-impact operations should keep explicit human approval regardless of benchmark performance.

Factuality evidence: better scores do not replace retrieval and citation discipline

OpenAI reports factuality improvements for Sol and Luna as part of the launch evidence. For knowledge workers, educators, legal-technology professionals, and enterprise teams, the correct interpretation is “worth evaluating for fact-heavy tasks,” not “safe to trust without sources.” Even a model with improved factuality can mix outdated knowledge, ambiguous context, overconfident wording, and unsupported inference.

The model-reference pages list different knowledge cutoffs: Sol is April 20, 2026; Luna is May 18, 2026; Astra is April 30, 2026. A later cutoff is not a quality ranking and does not mean the model knows every current fact before that date. Current law, policy, product behavior, prices, scientific evidence, software versions, and institutional rules still require retrieval from dated, authoritative sources and verification by qualified people where the stakes require it.

A practical factuality evaluation should contain three types of tasks. First, include answerable questions with authoritative source material already provided in context. Second, include current questions requiring retrieval from approved sources, with scoring for citation relevance and quote accuracy. Third, include unanswerable or underspecified questions where the correct behavior is to say what is missing, ask for clarification, or refuse to infer. This design tests not just knowledge but epistemic discipline.

Factuality workflow	Recommended evidence requirement	Model-selection implication
Internal policy Q&A	Quote or cite the approved policy source and identify the effective date.	Luna may be evaluated for high-volume routine answers; escalate ambiguous or high-impact interpretations.
Legal-technology research support	Use authorized legal sources, preserve jurisdiction and date, and require attorney review.	Benchmark factuality cannot authorize legal advice or filing without qualified review.
Education content drafting	Check age appropriateness, curriculum alignment, and source accuracy.	Use local review for student-facing material, especially health, safety, history, or civics topics.
Enterprise decision briefing	Separate sourced facts, assumptions, estimates, and recommendations.	Use stronger models for synthesis complexity, not as a substitute for source verification.

For regulated or high-impact domains, the model’s role should be framed as drafting, summarizing, comparing, or flagging evidence rather than making final determinations. A workflow that affects employment, credit, housing, education access, healthcare, legal rights, public benefits, or safety needs domain review, access controls, and auditability regardless of whether the model is Astra, Sol, or Luna.

Collaboration style: evaluate how the model works with humans, not only whether it finishes

OpenAI says Sol and Luna improve collaboration style, which is meaningful for ChatGPT Work, Codex, and API agents because many failures are interaction failures rather than pure reasoning failures. A model may solve a task but ignore constraints, bury uncertainty, ask too many questions, ask too few questions, over-edit a user’s work, or produce an answer that is technically correct but hard to review.

Collaboration-style evaluation should measure behaviors that matter in the user’s environment. For a founder, that may mean crisp tradeoff framing and explicit assumptions in an investor memo. For an enterprise administrator, it may mean following workspace policy and identifying permission boundaries. For a teacher, it may mean adapting an explanation without collecting unnecessary student data. For a security analyst, it may mean separating confirmed indicators from hypotheses and avoiding instructions that intensify harm.

A useful scoring rubric includes constraint retention, question quality, uncertainty labeling, evidence presentation, refusal appropriateness, edit minimality, and handoff readiness. Handoff readiness is especially important for professional work: the model should produce an artifact that a human can approve, reject, or revise without reconstructing hidden reasoning. It should not claim access to raw chain-of-thought, and applications should not require raw chain-of-thought disclosure as a condition of trust.

Recommended collaboration-style rubric fields:
- Did the model preserve the user's stated constraints?
- Did it ask clarifying questions only when needed?
- Did it distinguish facts, assumptions, estimates, and recommendations?
- Did it provide enough evidence for review without exposing sensitive material?
- Did it identify tasks requiring human approval?
- Did it avoid claiming that unverified work was completed?
- Did it produce a usable handoff artifact for the next reviewer?

Prompt caching evidence: cost and speed optimizations are not capability improvements

OpenAI’s GPT-6 prompt-caching announcement is operationally important because supported GPT-6 workflows can receive discounts of up to 90% on eligible cached input-token reads. The official caching documentation states that cache writes cost 1.25 times the uncached input rate and reads cost 0.1 times that rate for GPT-5.6 and later. This means repeated stable prefixes can materially change task economics, but prompt caching does not make a model more truthful, more authorized, or safer.

The caching evidence also has customer-example caveats. OpenAI reports that GitHub saw more than a 50% reduction in prompt tokens requiring fresh processing against its previous baseline, and that one Manus example improved from roughly 85% to above 90% cache hit rate. These are attributed examples from specific customers and workflows. They are not promises that a team using Sol, Luna, or Astra will see the same cache hit rate, cost reduction, latency behavior, or architectural fit.

Cache behavior depends on an unchanged rendered prefix and compatible settings. The official documentation warns that model, tools, tool ordering, structured-output schema, reasoning effort, verbosity, context management, compaction, service tier, and earlier input changes can affect reuse. A session does not guarantee a cache hit, and a diagnostic cache_hit does not mean the entire current prompt came from cache. Actual reuse must be measured with usage.input_tokens_details.cached_tokens.

The practical consequence is that benchmark cost-per-task comparisons should be cache-normalized before procurement decisions. A model with a higher uncached input price might be viable if a large stable prefix is reused heavily; a cheaper model may still be expensive if it generates long outputs, uses high effort, retries often, misses cache, calls tools, or crosses the long-context pricing threshold above 272,000 input tokens. Costs should be broken out into uncached input, cache writes, cached reads, output and reasoning tokens, tool charges, processing mode, regional premium where applicable, retries, and failed attempts.

Caching and reasoning effort: preserve prefixes only when the task remains semantically valid

OpenAI’s caching guidance for GPT-6 adds an important mechanism: reasoning effort can be changed through an appended configuration_update without rewriting the earlier cached prefix, while top-level reasoning changes can affect cache reuse. This is useful for long-running conversations or agent sessions where a stable policy, tool list, and context foundation should remain unchanged while a later step needs different reasoning intensity.

The mechanism should not be abused to preserve cache hits when the earlier context is no longer correct. If a policy changes, a tool schema changes, a user revokes permission, a data boundary changes, or a safety instruction is superseded, the application should update the prefix even if that causes a cache miss. Cache efficiency is subordinate to correctness, authorization, and governance.

For tool-heavy agents, OpenAI recommends keeping tool definitions, schemas, and ordering stable where operationally correct, and changing callability with allowed_tools or tool_choice: none instead of removing definitions when possible. That is a caching tactic, not a permission model by itself. The application must still enforce least privilege outside the model, validate tool arguments, log calls, and require approval for consequential actions.

Alignment and safeguard evidence: challenge tests should trigger controls, not complacency

OpenAI’s system-card evidence for GPT-6 Astra, including the Sol/Luna appendix, covers model safety, robustness, health, hallucinations, alignment, monitorability, preparedness, and safeguards. The document’s repeated caveats are central to responsible adoption: results are evaluations under defined conditions, remaining failures exist, evaluation awareness can affect behavior, and monitorability has limits. These statements are not boilerplate; they are operating constraints.

OpenAI states that Sol and Luna improve on GPT-5.6 counterparts in several alignment tests, including lower rates of misleading claims about coding work. For security and engineering teams, that result should inform test design. Include tasks where the model cannot complete the work, lacks tool access, encounters failing tests, or receives ambiguous instructions. Score whether it admits the limitation, asks for the missing input, proposes a safe next step, or falsely claims success.

Safeguards also require bidirectional interpretation. If a safeguard pauses or stops legitimate work, teams need a review path that does not pressure users to bypass controls. If a safeguard allows work to continue, teams still need application-level authorization, monitoring, and review. OpenAI’s Astra launch materials explicitly note that monitoring cannot replace alignment and that monitorability remains an active research problem; therefore, logs and monitors are necessary but not sufficient.

Safety evidence area	What it supports	What it does not prove	Recommended control
Alignment challenge tests	Comparative evidence under deliberately difficult scenarios.	Typical-use incident rates or a guarantee against deception.	Task-status verification, evidence requirements, and human review.
Hallucination and factuality tests	Directional evidence about answer reliability in defined settings.	Truthfulness for current, private, legal, medical, financial, or local facts.	Retrieval, source citation, dated references, and domain review.
Monitorability evaluations	Insight into whether problematic behavior can be observed under test conditions.	Complete detection of hidden or future failure modes.	Defense in depth: logs, approvals, sandboxing, rate limits, and incident response.
Safeguard behavior	Evidence that certain classes of unsafe work may be interrupted.	Perfect blocking of unsafe actions or perfect completion of legitimate work.	Escalation procedures, user education, and no-bypass policy.

Monitorability: logs help, but they are not a substitute for bounded authority

Monitorability is often misunderstood as a way to make powerful agents safe after the fact. OpenAI’s deployment-safety language is more cautious: monitoring has limits and cannot replace alignment. In production, logs are essential for debugging, audit, incident response, and user support, but they do not undo an unauthorized payment, an exposed record, a bad merge, or a submitted filing.

Effective monitorability starts before deployment. Teams should log model ID, versioned prompt or instruction bundle, reasoning effort and mode, tool definitions, tool calls, tool arguments, approval events, cache metrics, retrieved sources, output status, incomplete responses, user-visible result, and rollback action. Sensitive data should be minimized and protected according to policy; logs should not become a new repository of secrets, personal records, privileged material, or regulated data.

Applications must also handle incomplete responses explicitly. OpenAI’s reasoning guidance states that reasoning tokens are billed as output tokens and count against output/context limits even though they are not visible. If max_output_tokens ends a response as incomplete, the application may receive no usable visible answer. A safe agent treats incomplete status as a failure or escalation condition, not as permission to infer what the model “probably meant.”

Customer examples and competitor-source caveats

OpenAI’s launch and caching pages include benchmark comparisons and customer-reported examples, but the source boundary matters. The Sol/Luna launch article states that competitor results came from public reports, and some cost comparisons have stated limitations. Publicly reported competitor numbers may use different harnesses, effort settings, prices, tools, or environments. They are useful market context, not procurement-grade equivalence.

Customer examples should be read as case studies, not expected outcomes. A company with a stable long prefix, repeated agent loop, disciplined tool schema, and high request volume may benefit more from caching than a team with short one-off prompts and constantly changing context. Similarly, a coding agent integrated with repository tests and structured patch application may see different performance from a chat-based assistant that only suggests code snippets.

The most defensible comparison process is to reproduce the business-relevant task class in a controlled local harness. That harness should include representative data, edge cases, adversarial prompts, tool failures, permission boundaries, human-review labels, and cost accounting. It should compare Astra, Sol, and Luna only under configurations each model actually supports, rather than forcing a shared setting that one model reference does not list.

Decision rules from the benchmark and safety evidence

A practical decision rule for Astra is to reserve it for the hardest tasks where higher capability is worth the higher listed token price and where the workflow can absorb the cost, latency, and review burden. Examples include complex end-to-end software changes, multi-document synthesis with high ambiguity, difficult tool orchestration, or high-stakes professional drafting. Even then, Astra’s stronger positioning does not remove the need for retrieval, tests, approval, and rollback.

A practical decision rule for Sol is to evaluate it first for complex coding, agentic automation, and professional work where Astra may be more expensive than necessary but Luna may not provide enough margin. OpenAI’s reported AutomationBench and DeepSWE results make Sol a credible candidate for serious workflows, especially when prompt caching and right-sized reasoning effort are available. The local test should verify whether Sol’s outputs are correct, reviewable, and cheaper on total task cost, not merely cheaper per input token than Astra.

A practical decision rule for Luna is to evaluate it for high-volume focused work, routine coding tasks, structured extraction, summarization, and support workflows where the cost profile matters and the task is bounded. OpenAI’s reported DeepSWE 1.1 Luna max result suggests it should not be dismissed for coding, but low list price must not become an excuse to widen access, reduce review, or skip evaluation. Luna can still produce expensive tasks if prompts are long, outputs are large, cache misses are frequent, or retries pile up.

Across all three models, route by task risk rather than model prestige. A low-risk draft can often use a cheaper model with review. A high-risk action may need a stronger model for planning but still require human execution. A regulated decision may not be appropriate for autonomous model action at all. The model is one component in a controlled system, not the control system itself.

What the benchmark and safety sources do not establish

The official sources do not establish guaranteed workload savings. API list prices, cache discounts, and benchmark cost-per-task figures are inputs to a cost model, not a bill forecast. Actual spending depends on token volume, reasoning effort, output length, cache writes and reads, long-context multipliers, tools, retries, processing mode, regional processing, and application architecture.

The sources do not establish universal latency rankings. Pro mode performs more model work and can increase token usage and latency; Fast mode has separate pricing; cache hits can reduce repeated computation; tool calls can dominate wall-clock time. A local workload with web search, file search, hosted shell, computer use, or code execution may have latency behavior that public benchmarks do not capture.

The sources do not establish reliability guarantees. Benchmark scores, factuality evaluations, and alignment tests are measured under defined conditions. Production prompts, users, tools, data, policies, and adversarial behavior can differ. Continuous evaluation and incident review remain necessary after rollout.

The sources do not establish regional availability or plan access for every organization. Work and Codex availability depends on plan, role, workspace settings, and rollout. API regional processing, data residency, and processing modes have their own documented constraints and premiums. A configured workspace default does not grant a user access to a model unavailable to that user’s role.

The sources do not establish that safeguards will always block unsafe requests or always allow legitimate work. OpenAI’s Astra materials explicitly preserve safeguard and monitorability caveats. Production systems need defense in depth: access control, sandboxing, approval gates, audit logging, data minimization, rollback, user training, and incident response.

The sources do not establish application-specific fit. A model that performs well on AutomationBench, Agents’ Last Exam, FrontierCode, DeepSWE, OSWorld, or factuality tests may still fail a company’s internal workflow because the workflow has unusual data, tools, policy constraints, UI steps, latency targets, review requirements, or user behavior. Local evaluation is the deployment gate.

Operational workflow: convert public evidence into a local evaluation plan

1. Define the decision. State whether the evaluation is choosing a default model, an escalation model, a low-cost route, or a task-specific agent configuration.
2. Preserve model-specific settings. Validate the supported reasoning efforts, endpoints, tools, and function-calling constraints for Astra, Sol, and Luna before running comparisons.
3. Build representative tasks. Include ordinary cases, edge cases, adversarial cases, tool failures, ambiguous instructions, incomplete information, and tasks that should be refused or escalated.
4. Measure total task cost. Record uncached input, cache writes, cached reads, output and reasoning tokens, long-context multipliers, tool fees, retries, processing mode, and regional premiums where applicable.
5. Score human-review quality. Judge whether the output is correct, complete, source-grounded, uncertainty-aware, and ready for an authorized reviewer.
6. Test action boundaries. Confirm that the model cannot perform external side effects without the required application approval path.
7. Monitor after canary release. Track failures, cache behavior, incomplete responses, user corrections, approval overrides, and rollback events.
8. Keep rollback bundled. Restore model selection, prompt/cache policy, tool availability, and state-handling behavior together if the rollout fails.

This workflow keeps public benchmarks in their proper role. AutomationBench, Agents’ Last Exam, FrontierCode, DeepSWE, OSWorld, factuality tests, alignment challenge sets, caching case studies, and safeguard reports can all shape hypotheses. The production decision still belongs to the organization’s own evidence, controls, and risk tolerance.

Task-by-task selection framework for Sol, Luna, and Astra

The safest production framework is to treat Luna, Sol, and Astra as candidates for specific task classes rather than as a single ladder where every request should climb until it “feels smart enough.” OpenAI positions Luna as the lowest-cost GPT-6 option in this set, Sol as a stronger lower-cost model for complex work, and Astra as the strongest overall model. That positioning is useful for initial triage, but the deployment gate should be a local evaluation that measures correctness, review burden, latency, total cost, tool behavior, privacy fit, and rollback feasibility for your own workload.

A practical routing design begins with a task inventory. Split work by objective, input type, output risk, required tools, authority level, review path, and frequency. A high-volume summarization workflow with stable instructions is a different routing problem from a coding agent that edits a repository, which is different again from a multi-step enterprise workflow that can affect customer records, contracts, production infrastructure, or public communications. Model choice should follow those operational differences, not only token price or public benchmark results.

Task class	Starting candidate	Why this is only a starting point	Required local evidence before rollout	Human review rule
High-volume focused work: classification, extraction, templated summarization, first-pass research sorting, routine internal drafting	Luna	Luna has the lowest listed Standard API prices among the three, but cheap input and output tokens do not guarantee lowest total task cost when retries, tools, long contexts, cache writes, and review time are included.	Representative accuracy, false-positive and false-negative rates, token and cache accounting, latency distribution, incomplete-response handling, and reviewer correction rate.	Human approval is required before publication, regulated use, external messaging, account changes, payments, or any consequential action based on the output.
Complex coding and agentic workflows: multi-file analysis, patch drafting, tool selection, repository navigation, issue triage, test-plan generation	Sol	OpenAI reports strong coding and professional-work evaluations for Sol, but benchmark performance does not prove mergeability, security, maintainability, or correct behavior in your stack.	Patch correctness, test results, static-analysis results, reviewer acceptance, tool-call precision, sandbox safety, rollback behavior, and failure taxonomy.	Authorized engineers must approve merges, deployments, permission changes, destructive operations, and external submissions.
Hardest end-to-end work: ambiguous multi-step reasoning, high-stakes analysis support, complex agent plans, difficult synthesis, executive or legal-operations preparation	Astra	OpenAI positions Astra as strongest overall, but that does not authorize unattended operation or remove the need for verification, access control, and escalation.	Criterion-based quality scores, expert review, source verification, tool audit, latency and spend envelopes, regional/data controls, and incident-response readiness.	Qualified human decision-makers must approve legal commitments, compliance positions, medical or financial decisions, public claims, production changes, and other high-impact outcomes.

For high-volume focused work, begin by proving that the task is actually stable. A stable task has consistent input format, a narrow output schema, a known review standard, and limited need for external tools. Examples include routing support tickets into internal categories, extracting fields from approved business documents, summarizing internal meeting notes for the same team, or drafting a first-pass response that a human will edit. If the input distribution changes by customer, jurisdiction, department, or season, run separate eval slices rather than assuming one aggregate pass rate is enough.

For complex coding and agentic workflows, treat tool access and repository state as part of the model configuration. OpenAI’s model references list broad tool support through the Responses API, but tool availability does not mean the model should receive broad authority. A Sol-based coding workflow should run in a sandbox, use least-privilege repository permissions, avoid secrets, record tool calls, and require human approval before merge or deployment. A model that writes a plausible patch but invents a test result, misreads a build failure, or edits an unrelated file can create more operational cost than a slower model that produces less code but flags uncertainty accurately.

For the hardest end-to-end work, reserve Astra for tasks where incremental capability is worth the higher listed token price and expected latency or effort cost. Examples include complex architecture review, high-stakes incident synthesis, difficult regulatory research support, and multi-step planning where failure would be expensive to detect late. Even in those cases, Astra should produce evidence, options, and decision support rather than unapproved final actions. The strongest model in the family is still a component inside a controlled system.

This article explains OpenAI’s Model Misalignment Reporting Framework for documenting agent behavior, oversight concerns, and unauthorized-action disclosures. The OpenAI Launches a Model Misalignment Reporting Framework: Six Disclosures on Agent Behavior, Oversight, and Unauthorized Actions article is a focused companion for Model Safety Evaluation because the current article covers alignment and factuality, and this target adds directly relevant safety-evaluation context around misalignment reporting and agent oversight.

Local evals: the minimum viable evidence package

OpenAI’s evaluation guidance recommends task-specific objectives, representative data, explicit metrics, comparisons, and continuous evaluation. Apply that guidance before moving traffic among Luna, Sol, and Astra. Public benchmark scores can help decide what to test first, but they should not serve as a production gate because your prompts, tools, source materials, users, review standards, and error costs will differ from the evaluation setting.

A minimum local eval set should include typical cases, edge cases, adversarial cases, tool-selection cases, tool-argument cases, and handoff cases. For a coding workflow, include routine bug fixes, ambiguous issues, failing tests, dependency conflicts, security-sensitive files, and cases where the correct action is to ask for clarification. For a research workflow, include current facts requiring retrieval, conflicting sources, stale internal documents, and questions where the correct answer is “the evidence is insufficient.” For an enterprise administration workflow, include permission boundaries and cases where the model must refuse to proceed without authorized approval.

Eval dimension	What to measure	Why it matters for model selection	Recommended threshold type
Task correctness	Exact-match fields, rubric score, reviewer acceptance, or executable test result.	Determines whether Luna is sufficient, Sol is needed, or Astra produces materially better outcomes.	Pass/fail plus severity-weighted error rate.
Factuality and evidence	Unsupported claims, citation accuracy, source freshness, contradiction handling, and uncertainty labeling.	Prevents substituting a higher benchmark score for source verification.	Critical-fact error ceiling and mandatory escalation categories.
Tool behavior	Correct tool choice, argument precision, avoided tools, failed calls, and recovery behavior.	Agentic workflows often fail through tools rather than prose.	Tool-call precision and unsafe-call zero-tolerance rules.
Review burden	Minutes per review, number of edits, reviewer confidence, and escalation frequency.	A cheaper model can be more expensive if reviewers must spend substantially more time correcting it.	Total human-plus-token cost per accepted task.
Cost and latency	Uncached input, cache writes, cached reads, output and reasoning tokens, tool fees, retries, processing mode, regional premium, and p50/p95 latency.	List prices are incomplete without workload shape and mode choices.	Budget envelope and latency service objective.
Safety and policy fit	Refusals, unsafe completions, overconfident actions, permission requests, and review compliance.	Alignment tests are not production incident-rate estimates, so local safety checks remain necessary.	Severity-based stop conditions.

Use pairwise or criterion-based scoring rather than vague open-ended judgments. A reviewer comparing Luna and Sol on the same redacted support-ticket sample should answer concrete questions: Did the output assign the right category? Did it cite the right policy? Did it omit sensitive content? Did it ask for approval before proposing an account change? Did it use the required JSON schema? These questions produce actionable evidence; a score such as “looks good” does not.

If an LLM judge is part of the eval harness, calibrate it against human labels and watch for position bias, verbosity bias, and preference for confident language. The judge should use an explicit rubric and should not be the only approval mechanism for high-impact deployment. OpenAI’s notes also state that its current Evals platform is being deprecated, with read-only status for existing users on October 31, 2026 and shutdown scheduled for November 30, 2026. Do not build a new critical production dependency on that retiring platform; maintain an application-owned eval harness or a supported current evaluation path that preserves your test cases, metrics, and audit records.

Privacy, data region, and tenant boundaries

Model selection must preserve privacy boundaries. A decision to use Luna for cost, Sol for coding, or Astra for difficult analysis should not change which data the application is allowed to send, which user or tenant owns the request, which region applies, or which logs are retained. OpenAI’s prompt-caching documentation states that caches are not shared across organizations or regional processing boundaries, and model-reference notes indicate regional processing premiums and EU data residency conditions for Sol and Luna where available. Teams should confirm current account, region, and policy settings before deployment rather than assuming availability from a public model page.

For enterprise administrators, the operational rule is simple: route within the approved data boundary first, then optimize model and cache behavior inside that boundary. Do not move a regulated or contractually restricted workload to a cheaper route if that route changes regional processing, logging, access, review, or retention assumptions. Do not use prompt cache keys as a substitute for authorization. Cache keys may help with accounting or isolation, but they do not guarantee a hit, pin a request to a machine, validate data sharing, or create a privacy policy.

For multi-tenant applications, keep tenant-specific prefixes, tools, retrieval indexes, files, and audit records separate. Prompt caching reuses matching rendered prefixes; it is not semantic memory, source validation, or permission inheritance. Stable shared instructions can be valuable, but tenant-specific records, customer identifiers, confidential policies, and regulated material require explicit governance. If a prefix contains sensitive tenant material, the approval process should cover why it is included, who can trigger reuse, how accounting is separated, and what incident evidence will be available if behavior changes.

Spend, latency, caching, and incomplete-response controls

Cost control requires more than comparing the Standard token prices. For each candidate model, record uncached input tokens, cache-write tokens, cached-read tokens, output tokens, reasoning tokens, tool charges, retries, processing mode, regional premium, and whether the request crosses the documented 272,000-input-token threshold that changes rates for the full request. Reasoning tokens are billed as output tokens, even though they are not visible, so an apparently short answer can still carry meaningful output cost when reasoning mode or effort increases model work.

Prompt caching can materially change cost and latency for repeated prefixes, but the break-even depends on reuse. The documented GPT-5.6-and-later pattern uses a cache write at 1.25 times the uncached input rate and cached reads at 0.1 times the input rate. That means a cache write plus one full cached read can be cheaper than processing the same prefix uncached twice, but a one-off write is not automatically cheaper than an ordinary request. Cache optimization is most useful for stable system instructions, tool definitions, schemas, documents, and conversation prefixes that are reused within the eligible window and do not need to be rewritten.

OpenAI’s GPT-6 caching guidance also states that changing reasoning effort can be handled with an appended configuration_update on GPT-6 while preserving the earlier cacheable prefix, whereas top-level reasoning changes can affect reuse. Treat that as an engineering optimization, not a permission shortcut. If the task changes materially, preserving an old prefix may be semantically wrong even if it is cache-friendly. Stable tool definitions and schemas should remain stable only when they accurately represent the tools the model may use; use callability controls such as allowed tools or no-tool choices where appropriate rather than deleting and re-adding definitions solely to chase cache hits.

Applications must also handle incomplete responses. OpenAI’s reasoning guidance notes that max_output_tokens can produce an incomplete response, potentially before any visible output is produced. A production system should not treat missing text as approval, denial, success, or a safe default without an explicit rule. For low-risk drafting, the rule may be “retry once with the same model and then escalate.” For a coding agent, the rule may be “discard partial patch state, preserve logs, and require human review.” For a compliance or legal-operations workflow, the rule should be “do not proceed; notify the responsible reviewer with the evidence trail.”

{
  "routing_record": {
    "task_class": "coding_patch_review_support",
    "candidate_model": "gpt-6-sol",
    "reasoning_effort": "high",
    "processing_mode": "standard",
    "region_policy_checked": true,
    "tools_allowed": ["file_search", "code_interpreter"],
    "external_side_effects_allowed": false,
    "human_approval_required_before_merge": true,
    "cost_fields_to_record": [
      "uncached_input_tokens",
      "cache_write_tokens",
      "cached_read_tokens",
      "visible_output_tokens",
      "reasoning_output_tokens",
      "tool_charges",
      "retries",
      "long_context_multiplier_applied",
      "regional_processing_premium_applied"
    ],
    "failure_handling": {
      "incomplete_response": "stop_and_escalate",
      "unsafe_tool_request": "block_and_log",
      "schema_violation": "retry_once_then_escalate"
    }
  }
}

Permissions, tools, and review gates

A lower-cost model route never authorizes broader action scope. If a workflow was approved to draft email but not send it, switching from Astra to Sol or Luna should not add send permissions. If a coding assistant was approved to propose patches but not merge them, switching models should not change repository rights. If a financial-operations assistant was approved to summarize invoices, it should not gain payment authority because a benchmark suggests better agentic performance.

For tool-rich workflows, define an authority matrix independent of model identity. The matrix should specify which tools each workflow can call, which arguments are allowed, which resources are in scope, which operations are read-only, and which actions require approval. For example, a Work or Codex workflow may be allowed to read a selected repository, run tests in a sandbox, and draft a patch, but blocked from changing production secrets, modifying access control, publishing a release, or sending external communications without an authorized reviewer.

Operation	Model may draft or analyze?	Model may execute without approval?	Required control
Internal summary or classification	Yes, if data use is approved.	Only when the workflow is low-impact and preapproved.	Sampling review, audit logs, and error monitoring.
External email, support response, public post, or customer-facing answer	Yes.	No.	Human approval, factual verification, and policy review for sensitive cases.
Code patch or configuration change	Yes, in a sandbox or controlled workspace.	No for merge, deployment, destructive change, or permission change.	Tests, code review, security review where applicable, and rollback plan.
Payment, purchase, booking, legal commitment, account change, or regulated decision	Only as decision support with approved data.	No.	Authorized human decision-maker and documented evidence.
Computer-use action on live systems	Only within explicit scope.	No for consequential or irreversible actions.	Least privilege, session recording where lawful and approved, confirmation gates, and emergency stop.

Computer-use and agentic capabilities deserve special caution because the failure mode can be an action, not merely a sentence. Even if a model performs well in a benchmarked UI environment, production applications vary by layout, latency, permissions, hidden state, error messages, accessibility labels, and user account privileges. A safe computer-use deployment should start in observation or shadow mode, progress to supervised low-risk actions, and retain a human checkpoint before irreversible steps.

Rollback and staged deployment

Rollback must restore the whole validated behavior bundle, not just the model ID. A model migration can change prompt assumptions, reasoning effort, tool behavior, structured-output reliability, cache layout, latency, token budget, retry policy, and review burden. If a new Luna route fails in production, reverting only from gpt-6-luna to an earlier model while leaving the new prompt, cache policy, schema, or tool definitions in place may not recreate the prior safe state.

A staged rollout should proceed through offline eval, shadow traffic, limited canary, expanded canary, and general availability only if the stop conditions remain clear. Shadow traffic should prevent external side effects and avoid sending unapproved sensitive data into test corpora. Canary traffic should use least privilege, explicit reviewer assignment, cost caps, and rapid rollback authority. General availability should still include sampling review, anomaly detection, and a path for users to flag low-quality or unsafe outputs.

1. Freeze the baseline. Record the current model, prompts, schemas, tools, region settings, cache settings, retry policy, review rules, and observed cost/latency metrics.
2. Run offline comparisons. Compare Luna, Sol, and Astra only on approved, redacted, synthetic, public, or organization-approved evaluation data.
3. Test shadow execution. Send representative traffic without allowing external messages, code merges, payments, account changes, or destructive actions.
4. Open a narrow canary. Limit users, tenants, tools, regions, and spend while reviewers inspect outputs and tool traces.
5. Monitor stop conditions. Track critical errors, unsafe tool requests, cost anomalies, cache misses, latency spikes, incomplete responses, and reviewer rejection rate.
6. Rollback as a bundle. Restore the prior model, prompts, cache policy, tool availability, state handling, and review workflow together.
7. Re-evaluate periodically. Repeat evals when prompts, tools, data sources, model settings, pricing, product availability, region policy, or user behavior changes.

Periodic re-evaluation is not optional for long-lived systems. Model behavior can vary by plan, account, rollout, app surface, region, processing mode, workspace policy, and configuration. Your own workload also changes as users learn to prompt differently, documents evolve, repositories grow, tools change, and reviewers become more or less tolerant of specific failure types. A monthly or release-based re-evaluation cadence is a practical minimum for important workflows; high-impact systems should re-run targeted evals after every material configuration or policy change.

What the sources do not establish

The official sources establish model positioning, documented API prices, model IDs for Sol and Luna, specifications, selected benchmark results, caching mechanics, and safety-evaluation caveats. They do not establish that any organization will receive a specific cost reduction, latency improvement, reliability level, safety outcome, regional configuration, plan entitlement, or production fit. This distinction is essential because many operational failures come from treating launch claims as deployment evidence.

They do not establish guaranteed workload savings

OpenAI states that Sol and Luna are 50% cheaper than their GPT-5.6 promotional prices, and the model pages publish token prices for Standard, cached input, cache writes, and other processing options. Those facts do not guarantee that a workload’s total bill will fall by 50%, or at all. Total cost depends on prompt length, output length, reasoning tokens, cache writes, cached reads, retries, tool charges, long-context multipliers, processing mode, regional premiums, application architecture, and human review time.

They do not establish universal latency

The sources describe Sol and Luna as faster and more affordable members of the GPT-6 family, but they do not give a universal latency guarantee for every request pattern. Latency can vary with input size, output size, reasoning mode, reasoning effort, tools, streaming, cache behavior, processing mode, region, network conditions, service tier, and workload concurrency. A team that cares about user-facing response time should measure p50, p95, and timeout behavior in its own environment rather than assuming a launch-positioning phrase predicts production latency.

They do not establish reliability for your application

OpenAI’s benchmark and factuality results are evaluation-specific. They do not prove that a model will correctly handle your database schema, internal policies, obscure codebase, legal template, medical-adjacent content, education policy, customer tone, or adversarial user behavior. The system-card caveats also warn that absence of observed failures in an evaluation does not establish reliability across settings. Application owners remain responsible for representative evals, monitoring, escalation, and incident response.

They do not establish safety guarantees or incident rates

OpenAI’s alignment and deception-related evaluations are challenge tests under defined conditions, not prevalence estimates for ordinary use and not guarantees that a model will never mislead, overclaim, omit uncertainty, or take an unsafe path. Safeguards may also pause or stop legitimate work. The correct operational response is not to trust the model more broadly, but to keep authority bounded, require human approval for consequential operations, and maintain logs that support investigation when behavior is disputed.

They do not establish regional availability for every account

The model references describe regional processing premiums and EU data residency conditions for Sol and Luna where available, but public documentation does not prove that a particular account, region, organization, plan, or workspace has access to a given processing path at a given time. Enterprise administrators should verify current account configuration, contractual terms, workspace policy, and regional routing before migrating workloads that carry data-location obligations.

They do not establish ChatGPT Work, Codex, or Chat access for every user

The launch and Help Center notes distinguish Work, Codex, desktop access, ordinary Chat, plan eligibility, workspace settings, role permissions, and rollout. A workspace starting default does not grant a model to a user who lacks access. API billing and ChatGPT plan allowances are also separate. Administrators should document which users, roles, surfaces, and workflows are in scope before communicating availability or changing defaults.

They do not establish that a shared context window means equal fit

The Sol, Luna, and Astra model references list the same documented context window, input ceiling, and output ceiling. That shared specification does not mean the models have equal capability, equal latency, equal cost, equal tool behavior, or equal suitability for long-context tasks. Long prompts can also trigger documented pricing multipliers above 272,000 input tokens, so using the full context window should be justified by measured task value rather than by capacity alone.

They do not establish that prompt caching validates content

Prompt caching reduces repeated computation for matching prefixes. It does not prove that the prefix is correct, current, authorized, safe, or relevant. It does not replace retrieval, source checking, tenant authorization, access control, prompt-injection defenses, or human review. Cache diagnostics can help explain reuse behavior, but a diagnostic hit does not mean the entire prompt was cached, and diagnostics do not change model behavior.

They do not establish unsupported endpoint or feature availability

The cited model pages list supported and unsupported endpoints and features. They do not support assuming Assistants, Realtime, Live, fine-tuning, embeddings, speech, transcription, or legacy Completions support where the pages do not list it. Sol and Luna Chat Completions function calling is limited to reasoning_effort: none according to the cited notes, and OpenAI recommends the Responses API for built-in tools and normal function-calling workflows. Developers should validate settings per model instead of copying one configuration across the family.

Conclusion: choose by evidence, govern by risk, and revisit the decision

The cleanest comparison is not “Luna is cheap, Sol is smart, Astra is best.” The more reliable operating rule is: use Luna where focused high-volume tasks pass local evals with acceptable review burden; use Sol where complex coding, tool use, and agentic workflows justify more capability and cost; use Astra where the hardest end-to-end work warrants OpenAI’s strongest overall GPT-6 model and the organization is prepared to pay for and govern that choice. Each route must preserve privacy boundaries, regional rules, permissions, approval gates, audit logging, and rollback.

For founders and product teams, the opportunity is to lower cost or raise quality only after measuring the whole task. A Luna migration that increases retries or reviewer edits may not save money. A Sol coding assistant that drafts more code but increases security review burden may not ship faster. An Astra workflow that produces impressive analysis but lacks source verification and approval controls may increase risk. The right model is the one that improves accepted outcomes under your constraints.

For enterprise administrators and security teams, the main duty is to keep model enthusiasm from becoming permission drift. Changing the route must not change who can access data, which region processes it, which tools can run, what actions require approval, or how incidents are investigated. The sources support serious experimentation with Luna, Sol, and Astra, but they also preserve the need for staged deployment, monitoring, human review, and re-evaluation.

For advanced developers, the implementation pattern is straightforward: build a routing table, attach an eval suite to every route, log cost and cache details, handle incomplete responses explicitly, validate model-specific reasoning settings, prefer supported APIs for tool-rich workflows, and keep rollback bundles ready. Re-run the decision when prompts, tools, prices, data, users, regions, or OpenAI documentation changes. That is how a GPT-6 comparison becomes an operational advantage rather than a static ranking.

Evaluation-scope boundary: OpenAI reports Agents’ Last Exam and the other named benchmark results under stated evaluation settings. The alignment challenge-set values are not an incident rate, not a production failure rate, and not a typical-use failure rate; they do not establish deployment reliability or safety.

Useful Links

• OpenAI: Introducing GPT-6 Sol and Luna
• OpenAI: GPT-6 Astra
• OpenAI API model reference: GPT-6 Luna
• OpenAI API model reference: GPT-6 Sol
• OpenAI API model reference: GPT-6 Astra
• OpenAI: Better prompt caching for GPT-6
• OpenAI Deployment Safety Hub: GPT-6 Astra system card