That changes the practical decision for developers and IT teams. GPT-5.6 selection currently means choosing a hosted base model, setting its reasoning effort, building prompts and retrieval around it, and validating the result with task-specific evaluations. It does not mean training a customized Sol, Terra, or Luna derivative on proprietary examples through the fine-tuning API.
OpenAI’s documentation also supplies the figures missing from the Analytics Insight account. As of August 21, GPT-5.6 Sol costs $5 per million input tokens and $30 per million output tokens; Terra costs $2 input and $12 output; Luna costs $0.20 input and $1.20 output. For applications that generate long code patches, reports, agent traces, or document analyses, output pricing is the number likely to dominate a bill.
Fine-tuning is unavailable across the GPT-5.6 family
The word fine-tuning has a precise technical meaning in the OpenAI API: supplying training data to produce a modified model with behavior tailored to a recurring task. OpenAI’s individual catalog pages for Sol, Terra, and Luna list the fine-tuning endpoint among general platform endpoints, but each model’s feature matrix explicitly marks fine-tuning as “Not supported.”
That distinction is easy to miss and consequential for projects that have already budgeted time to curate JSONL training sets, establish training/validation splits, or create a model-governance process around custom snapshots. A fine-tuning workflow cannot simply be redirected to gpt-5.6-sol, gpt-5.6-terra, or gpt-5.6-luna.
Teams therefore need to separate two decisions that the supplied story runs together:
- Model selection determines the GPT-5.6 base capability, price point, supported tools, and reasoning budget.
- Customization for these models currently comes from system instructions, prompt templates, structured outputs, retrieval-augmented generation, tool design, and evaluation-driven iteration rather than training the model weights.
That does not make the models inflexible. OpenAI lists function calling, Structured Outputs, file search, web search, code interpreter, hosted shell, MCP, computer use, and other tools as supported for the family in the Responses API. For an enterprise application, those controls can impose substantially more reliable operational boundaries than a vague “make it answer like our staff” fine-tuning goal would have done anyway. But they carry a different engineering burden: teams must own their prompt versions, data retrieval quality, tool permissions, test cases, and regressions.
Sol, Terra, and Luna have a much wider price spread than the summary suggests
OpenAI describes Sol as the frontier member of the family, Terra as the balanced tier comparable to the former mini position, and Luna as the high-volume, cost-sensitive equivalent of the earlier nano tier. All three have a 1.05 million-token context window, a 128,000-token maximum output, image input, and the same broad tool menu. Those common specifications may make the three choices look interchangeable. They are not.
The current API prices show how sharply a high-volume deployment can diverge:
| Model | Input price per 1M tokens | Output price per 1M tokens | Intended use |
|---|---|---|---|
| GPT-5.6 Sol | $5.00 | $30.00 | Difficult coding, analysis, planning, and tool-heavy professional work |
| GPT-5.6 Terra | $2.00 | $12.00 | General production workloads that need capable reasoning at lower cost |
| GPT-5.6 Luna | $0.20 | $1.20 | Classification, extraction, routing, high-volume transformation, and other cost-sensitive jobs |
For a workload consuming one million input tokens and one million output tokens, those rates work out to roughly $35 on Sol, $14 on Terra, and $1.40 on Luna. That is a 25-fold gap between Sol and Luna on that simple mix. An agent that produces much more output than it receives widens the operational importance of the output column, because all three models charge six times as much for generated tokens as for standard input.
OpenAI also announced price reductions for Terra and Luna after the family’s initial rollout: Luna was cut by 80 percent and Terra by 20 percent. Developers relying on launch-day comparison spreadsheets should refresh them. Model names may be durable capability labels, but pricing is subject to change, and a cached cost model can lead an organization to choose the wrong tier for its present workload.
Reasoning effort is a control, not a substitute for model choice
Analytics Insight correctly notes that GPT-5.6 supports reasoning settings from none through max. OpenAI’s current documentation adds an intermediate xhigh setting, with medium as the default. In certain ChatGPT products, higher tiers can also surface under names such as Extra High, Pro, or Ultra, but API teams should use the documented reasoning.effort values rather than assume that a ChatGPT interface label maps directly to an API configuration.
The important operational point is that reasoning effort governs how much internal work the selected model can spend on a request. It is useful for tailoring latency and token consumption across work types, but it should not be treated as a universal quality dial.
A sensible implementation pattern is to start low for deterministic, narrow work: extracting fields from standardized invoices, classifying tickets, generating JSON that must match a schema, or routing a request to the right internal workflow. Raise effort for tasks that genuinely require multistep analysis, repository-wide code changes, ambiguous policy interpretation, investigation of an incident, or tool-based workflows where an early bad decision can compound across later steps.
The model tier still sets a ceiling. Luna at max effort may be an excellent fit for a well-bounded high-volume workflow, yet it should not be assumed to match Sol on difficult debugging, complex architecture decisions, or long-horizon autonomous coding. Conversely, running Sol at max effort on routine ticket triage can convert a cheap automation opportunity into an avoidable recurring cost.
OpenAI’s public benchmark claims favor Sol on advanced coding, cybersecurity, scientific reasoning, and agentic work, while Terra and Luna remain competitive in many categories. Those are vendor-reported comparisons, though, and they cannot determine whether a model handles a company’s coding conventions, internal documentation, Windows estate, security policy, or proprietary data accurately. The supplied story’s recommendation to test real tasks is therefore the most useful part of its advice.
The million-token context window has a billing catch
The 1.05 million-token context figure is substantial, but it should not be read as permission to put every available document into each request. OpenAI’s pricing pages set a higher rate for prompts above 272,000 input tokens: the full request is charged at twice the normal input rate and 1.5 times the normal output rate.
That means a request using an enormous context can become expensive even with Luna, and far more so with Sol. The advertised context maximum is a capacity ceiling rather than a recommendation for normal application architecture.
OpenAI provides prompt caching to reduce repeated-context expense. Cached input is priced at one-tenth of the normal input rate for these models, while cache writes are billed at 1.25 times the uncached input rate. The family also supports explicit cache breakpoints and a minimum 30-minute cache lifetime. Those details favor applications with a large, stable prefix—such as a long system policy, a coding standard, an indexed document header, or a repeated tool specification—followed by small per-user changes.
The practical design implication is clear: separate static context from changing context, reuse prefixes deliberately, and measure cache hit rates. Sending a complete knowledge corpus afresh for every request is a costly replacement for retrieval design, access controls, document hygiene, and selective context assembly.
An evaluation should choose the deployment tier
For a Windows-focused development or IT operation, an evaluation set should resemble the work that will actually reach production. A useful test suite might include PowerShell diagnostics, Intune policy explanations, Windows event-log summarization, Microsoft 365 administration questions, code-review findings, structured incident tickets, and tasks that call approved internal tools.
Each candidate should be measured on more than a preferred answer sample. Record correctness, schema validity, tool-call accuracy, grounding in supplied materials, security-policy compliance, median and worst-case latency, total input and output tokens, and the human correction required before a result can be acted on. Test the same cases at the reasoning settings that a production workload would realistically use.
Start with Luna when tasks are narrow, outputs are short, errors are cheap to detect, and request volume is high. Move to Terra when the lower tier loses too much accuracy or requires enough retries and human review to erase its savings. Reserve Sol for work where better reasoning, coding performance, or agent reliability can offset its materially higher output price.
GPT-5.6 gives developers unusually broad room to trade cost against capability without changing context limits or rebuilding around a different API feature set. The immediate constraint is that none of the three models can be fine-tuned today. Teams planning customization should build a prompt, retrieval, tool-permission, and evaluation discipline first—then choose Sol, Terra, or Luna based on measured task outcomes rather than the family’s marketing labels.