GPT-6 Sol was the current model for exactly one week. OpenAI replaced it at DevDay on 29 September 2026 with GPT-6.1 Sol: same $2 input and $10 output per million tokens, cached input cut in half to $0.10, and chart scores that land on top of GPT-6 Astra on software engineering. GPT-6 Sol and GPT-6 Luna, launched 22 September at half the price of GPT-5.6, stay on the price list.
This guide covers GPT-6.1 Sol, GPT-6 Sol and GPT-6 Luna specs, API pricing, the numbers in the OpenAI benchmark charts (including the ones the launch prose skipped), and a same-prompt DevOps test against Claude Opus 5.5 graded by real validators and a real cluster. The GPT-6.1 Sol runs, a streaming speed probe and the Kubernetes deploys were repeated on Ubuntu 26.04 with k3s v1.36.5 in October 2026.
The short read: GPT-6.1 Sol passed every check GPT-6 Sol passed, for about the same money, and it is the stronger model on paper. It is also half as fast. It streamed about 81 visible tokens per second on our probe against roughly 165 for GPT-6 Sol, and it rejects none as a reasoning effort. Luna is still absurdly cheap, and it still shipped a Kubernetes manifest that passes every linter and crashes on start.
GPT-6.1 Sol, GPT-6 Sol and Luna specs
All three share the shape of Astra: a 1.05M token context window, 128K max output, text and image in, text out. The differences sit in the knowledge cutoff, the reasoning ladder and the Chat Completions rules.
| Attribute | GPT-6.1 Sol | GPT-6 Sol | GPT-6 Luna |
|---|---|---|---|
| API model ID | gpt-6.1-sol | gpt-6-sol | gpt-6-luna |
| Released | 29 September 2026 | 22 September 2026 | 22 September 2026 |
| Positioning (OpenAI) | Near-Astra performance for complex work at a lower cost | Complex coding and agentic workflows | Focused, high-volume tasks |
| Context window | 1,050,000 tokens | 1,050,000 tokens | 1,050,000 tokens |
| Max output | 128,000 tokens | 128,000 tokens | 128,000 tokens |
| Knowledge cutoff | 30 April 2026 | 20 April 2026 | 18 May 2026 |
| Reasoning effort | low, medium (default), high, xhigh, max | none, low, medium (default), high, xhigh, max | none, low, medium (default), high, xhigh, max |
| Tool calling on Chat Completions | Not supported (Responses API only) | Only at effort none | Only at effort none |
| Fine-tuning | Not supported | Not supported | Not supported |
| Tier 1 rate limit | 500 RPM, 500K TPM | 500 RPM, 500K TPM | 500 RPM, 500K TPM |
The reasoning ladder is the change that breaks pipelines. Sol and Luna accept none; GPT-6.1 Sol and Astra do not. The GPT-6.1 Sol model page also drops tool calling from Chat Completions entirely, so any integration that relied on the GPT-6 Sol “function calling at effort none” path has to move to the Responses API before it can switch models. GPT-6.1 Sol supports US and EU data residency, but Fast mode is unavailable with EU residency.
Luna keeps the newest knowledge cutoff of the family. GPT-6.1 Sol gained ten days over GPT-6 Sol and now matches the Astra cutoff of 30 April.
GPT-6.1 Sol, GPT-6 Sol and Luna pricing
Token rates did not move. The only pricing change is cached input, which drops by half, and for agent loops that is the line that matters.
| Per 1M tokens | GPT-6.1 Sol | GPT-6 Sol | GPT-6 Luna | GPT-6 Astra |
|---|---|---|---|---|
| Input | $2.00 | $2.00 | $0.10 | $10.00 |
| Cached input (read) | $0.10 | $0.20 | $0.01 | $1.00 |
| Cache write | $2.50 | $2.50 | $0.125 | $12.50 |
| Output | $10.00 | $10.00 | $0.50 | $50.00 |
| Input / output above 272K prompt tokens | $4.00 / $15.00 | $4.00 / $15.00 | $0.20 / $0.75 | $20.00 / $75.00 |
| Predecessor input / output | $2.00 / $10.00 (GPT-6 Sol) | $4.00 / $20.00 (GPT-5.6 Sol) | $0.20 / $1.20 (GPT-5.6 Luna) | n/a |
Batch and Flex run at 50% of these rates, Fast mode at 2x, and regional processing (data residency) adds 10%. The 272K threshold applies to the whole request, so one oversized prompt bills 2x input and 1.5x output on every token in that call. Cache writes cost 1.25x input on every model here. Cache reads are 5% of input on GPT-6.1 Sol and 10% on the rest, so a prefix written once and replayed twenty times on GPT-6.1 Sol costs a little over two uncached sends.
The GPT-6 launch was a real price cut, with one footnote. The GPT-5.6 Sol price of $4/$20 was itself a promotional rate, so “half of GPT-5.6” is half of an already discounted number, and Luna output fell 58% ($1.20 to $0.50), not the advertised 50%. OpenAI did not announce a GPT-6 Terra; the lineup on the models page is Astra, GPT-6.1 Sol, GPT-6 Sol and Luna.
Against Anthropic, Sol token rates are exactly half of Claude Opus 5.5 ($4/$20) and a fifth of Claude Fable 5.1 ($10/$50). Opus 5.5 bills cache hits at $0.20 per million, the same as GPT-6 Sol and twice GPT-6.1 Sol. On agent loops that replay a large cached prefix, the input side matters less than output tokens, and output is where the per-task gap comes from.
GPT-6.1 Sol benchmarks against GPT-6 Sol, Astra and Opus 5.5
OpenAI plots every model at five effort levels on a score versus cost-per-task chart. The GPT-6.1 Sol launch page quotes selected points. The chart data underneath has all of them, so the table takes the best score of each model with the effort and cost per task that produced it.
| Benchmark (best score, effort, cost per task) | GPT-6.1 Sol | GPT-6 Sol | GPT-6 Astra | Claude Opus 5.5 (w/ fallbacks) |
|---|---|---|---|---|
| DeepSWE 1.1 | 75.2% (high, $0.65) | 68.8% (max, $2.74) | 74.1% (xhigh, $4.43) | not charted |
| GDP.pdf | 32.0% (high, $0.35) | 28.0% (high, $0.35) | 32.2% (xhigh, $1.91) | 28.8% (high, $0.83) |
| AutomationBench 1.0.6 | 36.1% (max, $0.30) | 33.2% (xhigh, $0.27) | 41.4% (max, $1.73) | 42.5% (max, $1.44) |
| OSWorld 2.0, offline | 71.4% (max, $1.27) | 64.4% (max, $3.37) | 73.5% (max, $9.44) | not charted |
| Terminal-Bench Science 0.1 | 57.0% (max, $5.47) | 27.6% (max, $12.18) | 68.1% (max, $23.80) | 63.3% (max, $23.21) |
| Factual error rate (lower is better) | 4.1% (xhigh, $0.10) | 4.5% (xhigh, $0.13) | 3.9% (high, $0.48) | not charted |
OpenAI undersold DeepSWE. The launch copy says GPT-6.1 Sol “matches” Astra there. On the chart, GPT-6.1 Sol at high effort scores 75.2%, above the Astra best of 74.1%, at $0.65 per task against $4.43. It also clears the 72.7% GPT-5.6 Sol ceiling that GPT-6 Sol fell short of.
The Opus 5.5 comparisons are picked as carefully as the ones a week earlier. On AutomationBench the prose reports GPT-6.1 Sol 2.2 points ahead of Opus 5.5 at medium effort, which the chart confirms (31.7% vs 29.5%). Opus 5.5 at max scores 42.5%, though, which beats the GPT-6.1 Sol best (36.1%) and the Astra best (41.4%). On Terminal-Bench Science, Opus 5.5 at max also beats GPT-6.1 Sol, 63.3% to 57.0%, at four times the cost per task. Where cost is no object, the Anthropic model still wins on agentic business workflows.
Effort is non-monotonic again. GPT-6.1 Sol at max scores 71.9% on DeepSWE, below its own 75.2% at high, while costing 2.4x more. The same happened to GPT-6 Sol on AutomationBench. Default to high for coding work and only go to max where a benchmark close to your workload shows it helps.
The cheapest gain is factuality at low effort. On the OpenAI adversarial factuality set the share of answers with an error drops from 11.4% to 7.7% at low effort, about a third fewer. At xhigh and max effort the two Sols are within half a point of each other.
One model is missing from the week. TechCrunch reported that there is no GPT-6.1 Astra, citing a Wall Street Journal report that OpenAI scrapped it after internal testing showed more deception and a tendency to proceed without asking for permission. GPT-6.1 Sol shipped with a system card addendum instead. Under the OpenAI Preparedness Framework it is treated as Critical in cybersecurity and High in the biological and chemical domain, so it runs behind the same safeguards stack as Astra. The addendum also reports modest cyber safety regressions against GPT-5.6 Sol in synthetic agentic environments.
What the GPT-6 Sol launch benchmarks showed, and what they left out
The GPT-6 Sol and Luna launch charts compared the new pair with GPT-5.6 and Claude Opus 5. Best score per model, with effort and cost per task:
| Benchmark (best score, effort, cost per task) | GPT-6 Sol | GPT-6 Luna | GPT-5.6 Sol | GPT-6 Astra | Claude Opus 5 |
|---|---|---|---|---|---|
| AutomationBench 1.0.6 | 33.2% (xhigh, $0.27) | 20.7% (max, $0.037) | 28.8% (max, $0.67) | 41.4% (max, $1.73) | 26.9% (max, $3.05) |
| Agents’ Last Exam V1 | 56.4% (max, $2.93) | 50.9% (max, $0.15) | 53.6% (xhigh, $5.08) | 59.3% (max, $6.23) | 55.9% (high, $7.29) |
| FrontierCode 1.1 Main | 49.3% (max, $2.14) | 42.4% (max, $0.11) | 47.5% (max, $5.19) | 53.3% (max, $4.59) | 53.4% (medium, $4.31) |
| DeepSWE 1.1 | 68.8% (max, $2.74) | 66.6% (max, $0.22) | 72.7% (max, $6.46) | 74.1% (xhigh, $4.43) | 73.7% (max, $11.84) |
| OSWorld 2.0, offline | 64.4% (max, $3.25) | 52.7% (max, $0.27) | 66.2% (max, $7.71) | 73.5% (max, $9.07) | 70.2% (max, $24.11) |
| Factual error rate (lower is better) | 4.5% (xhigh, $0.13) | 7.6% (max, $0.012) | 8.4% (xhigh, $0.39) | 3.9% (high, $0.48; same at max) | not reported |
| Coding deception rate (max effort, lower is better) | 1.3% | 2.8% | 10.4% | 0.5% | not reported |
The best GPT-6 Sol score was lower than the best GPT-5.6 Sol score on DeepSWE (68.8% vs 72.7%) and OSWorld 2.0 (64.4% vs 66.2%). The gain in that generation was a cost gain: at a matched budget it won clearly, beating GPT-5.6 Sol at high ($4.46) by 7.9 points on OSWorld while spending $3.25. GPT-6.1 Sol is the release that finally raises the ceiling. The OSWorld cost per task for GPT-6 Sol ($3.25 vs $3.37) and Astra ($9.07 vs $9.44) differs slightly between the two launch pages. The OpenAI charts note that comparison values for previously launched models may reflect later versions.
The Claude comparisons were chosen carefully then too. The GPT-6 launch text compared the Sol DeepSWE score to Claude Fable 5 (69.9%), not to Claude Opus 5, which the OpenAI chart itself put at 73.7%. Luna at xhigh (12.6%) scored below Luna at high (14.5%) on AutomationBench, the first sign of the effort pattern GPT-6.1 Sol repeats on DeepSWE.
The honesty numbers were the strongest part of that release. Coding deception, the share of answers where the agent misrepresents what its code does, fell from 10.4% to 1.3% for Sol and from 9.5% to 2.8% for Luna. GPT-6.1 Sol continues the trend on the OpenAI alignment set: it fails to disclose a broken search tool in 2.1% of adversarial cases, against 4.9% for GPT-6 Sol, 1.5% for Astra and 28.7% for Luna. These evaluations are built to provoke failures. Read the direction, don’t read the absolute rate.
Independent results from Artificial Analysis
Artificial Analysis published results for GPT-6 Sol and Luna on their launch day. Its headline matched the chart reading above: intelligence roughly level with GPT-5.6, cost per task cut in half.
- Running the Intelligence Index cost $1.06 per task on Sol (max) against $1.99 for GPT-5.6 Sol (max), and $0.07 on Luna (max) against $0.18. Both new models used slightly more output tokens per task (Sol 31K vs 29K, Luna 51K vs 41K), so the saving came entirely from the price cut.
- On the Coding Agent Index, run in the OpenAI Codex harness, Sol gained 2 points to 57 (Terminal-Bench 4.0 went from 37% to 43%). Luna lost 2 points to 41, with lower SWE-Atlas-QnA and DeepSWE scores than GPT-5.6 Luna.
- At max effort, hallucination on AA-Omniscience dropped from 92% to 60% for Sol and 93% to 77% for Luna. Sol got there by declining to answer more often: it attempted 83% of questions against 99% before, and its accuracy fell 5 points to 54%.
- At max effort, both regressed on GDPval-AA v2.1 knowledge work, about 100 Elo for Sol and 75 for Luna, which the testers traced to shorter deliverables that skip rubric elements.
That last point lines up with the OpenAI note that the GPT-6 models give “slightly shorter answers overall”. Shorter is good in a terminal. It is a regression if your workload grades on completeness, such as long reports or spreadsheets.
GPT-6 Sol vs Claude Opus 5.5 on the same DevOps tasks
Nobody had published Sol and Opus 5.5 on the same harness at launch, so we ran one in launch week. The three prompts are the exact ones from our Opus 5.5 release test: a Kubernetes Deployment and Service for nginx with probes, resource limits and a non-root securityContext; a bash script that dumps PostgreSQL, gzips it, uploads to S3 and prunes dumps older than 7 days; and an AWS VPC, public subnet, internet gateway, route table and security group in Terraform. Same system prompt (“output only the file”), default effort on every model (medium for Sol and Luna, confirmed in the API response), three runs per model per task, 27 calls in total. Costs are computed from the usage fields of each response at list prices.
Linters alone did not separate the models. All 27 files passed their validator: kubeconform -strict for the manifests, shellcheck for the scripts, tofu validate plus tofu fmt -check for the Terraform. So we ran the output too. Each backup script was executed against stub pg_dump and aws binaries to check that it fails when variables are unset, writes a valid gzip, uploads once, deletes a 10-day-old dump and keeps a 3-day-old one. Each manifest was deployed on its own to a single-node k3s cluster and probed with an HTTP request through its Service.
| Check (3 runs each) | GPT-6 Sol | GPT-6 Luna | Claude Opus 5.5 |
|---|---|---|---|
| Kubernetes: kubeconform -strict | 3/3 valid | 3/3 valid | 3/3 valid |
| Kubernetes: deploys and serves HTTP 200 on k3s | 3/3 | 0/3 (CrashLoopBackOff) | 3/3 |
| Bash: shellcheck | 3/3 clean | 3/3 clean | 3/3 clean |
| Bash: behaviour test (unset vars, gzip, upload, 7-day prune) | 3/3 | 3/3 | 3/3 |
| Terraform: tofu validate + fmt, all resources tagged | 3/3 | 3/3 | 3/3 |
| Passed every check | 9/9 | 6/9 | 9/9 |
| Total cost, 9 calls | $0.0841 | $0.0036 | $0.2732 |
| Mean output tokens (k8s / bash / tofu) | 981 / 1,005 / 718 | 548 / 997 / 766 | 1,823 / 1,692 / 894 |
| Mean latency (k8s / bash / tofu) | 12.5s / 15.7s / 8.4s | 9.1s / 16.3s / 11.5s | 15.0s / 16.9s / 7.2s |
Sol matched Opus 5.5 on every check and cost 69% less. The sticker price explains 2x of that 3.25x gap. The rest is token count: Sol wrote about 46% fewer output tokens than Opus 5.5 on the Kubernetes task and 41% fewer on the bash task. Luna came in 23 times cheaper than Sol and failed one task on all three runs.
Here is that failure on the cluster, with the first Sol manifest running next to it:
Error: mkdir() “/var/cache/nginx/client_temp” failed (13: Permission denied)
This is the classic non-root nginx trap, and Luna walked into it three times out of three. The prompt asked for runAsNonRoot on the stock nginx:1.27-alpine image. That image expects to write its cache and PID file as root, so a pod running as UID 101 dies on start unless those paths are writable. Luna set the user and nothing else. This is the container section from its first run, verbatim:
securityContext:
runAsNonRoot: true
runAsUser: 101
runAsGroup: 101Sol and Opus 5.5 both mounted emptyDir volumes over the paths nginx writes to, which is the fix. The first Sol run also dropped all capabilities except NET_BIND_SERVICE, disabled privilege escalation and set a RuntimeDefault seccomp profile without being asked. The relevant part of its pod spec:
volumeMounts:
- name: nginx-cache
mountPath: /var/cache/nginx
- name: nginx-run
mountPath: /var/run
volumes:
- name: nginx-cache
emptyDir: {}
- name: nginx-run
emptyDir: {}The lesson is bigger than nginx. A schema validator checks shape, not behaviour, and the Luna manifest has a perfect shape. If you route generation work to Luna, put a real deploy or execution step in the loop, not just a linter. A throwaway k3s cluster on Ubuntu 26.04 is enough to catch this class of bug.
The scripts showed a softer difference the tests did not penalise. All six Luna and Sol scripts write dumps into a path relative to the current working directory, which lands in whatever directory cron starts in. All three Opus 5.5 scripts used a BACKUP_DIR variable defaulting to /var/backups/postgres. Opus pays for that care in tokens; you pay for its absence in an audit.
GPT-6.1 Sol on the same DevOps tasks
We reran the harness for GPT-6.1 Sol with the same three prompts and system prompt, three runs each, at the default medium effort and again at high. GPT-6 Sol ran alongside it on the same day so the cost and latency columns compare like with like. Its numbers moved from the launch-week run (8.6 seconds per Kubernetes call instead of 12.5, $0.0687 for nine calls instead of $0.0841), which is normal run-to-run drift for a hosted model and the reason not to compare across days. All 27 outputs went through the same validators, and every manifest was deployed to a fresh k3s v1.36.5 node on Ubuntu 26.04.
| Check (3 runs each) | GPT-6.1 Sol (medium) | GPT-6.1 Sol (high) | GPT-6 Sol (medium) |
|---|---|---|---|
| Kubernetes: kubeconform -strict | 3/3 valid | 3/3 valid | 3/3 valid |
| Kubernetes: deploys and serves HTTP 200 on k3s | 3/3 | 3/3 | 3/3 |
| Bash: shellcheck -S info | 3/3 clean | 3/3 clean | 3/3 clean |
| Bash: behaviour test | 3/3 | 3/3 | 3/3 |
| Terraform: tofu validate + fmt | 3/3 | 3/3 | 3/3 |
| Passed every check | 9/9 | 9/9 | 9/9 |
| Total cost, 9 calls | $0.0642 | $0.0945 | $0.0687 |
| Reasoning tokens, 9 calls | 2,483 | 5,385 | 3,479 |
| Mean output tokens (k8s / bash / tofu) | 823 / 643 / 576 | 1,206 / 1,088 / 759 | 833 / 656 / 704 |
| Mean latency (k8s / bash / tofu) | 17.0s / 14.9s / 9.2s | 23.9s / 22.2s / 12.6s | 8.6s / 6.7s / 5.8s |
On pass rate there is nothing to pick between them; these prompts sit below both models’ ceiling. GPT-6.1 Sol used 29% fewer reasoning tokens than GPT-6 Sol and cost 7% less over nine calls. High effort added 47% to the bill and changed no result. The difference our harness did catch was time: GPT-6.1 Sol took roughly twice as long per call at medium, and close to three times as long at high.
Its manifests also took a different route to the same fix. Four of the six used the usual emptyDir mounts over /var/cache/nginx and /var/run. The other two mounted a single emptyDir at /tmp, wrote a complete nginx.conf there from the container start command with every temp path and the PID file pointed at /tmp, with the root filesystem read-only (most of the other manifests set that too). It works, and both deployments served HTTP 200, but a config generated inside args is harder to review and override than a ConfigMap. The backup scripts differed in one detail: every GPT-6.1 Sol script appended the process ID to the dump filename, so two overlapping cron runs cannot overwrite each other. None of the GPT-6 Sol scripts did.
How much slower is GPT-6.1 Sol?
GPT-6.1 Sol streams visible output at about half the GPT-6 Sol rate. To separate thinking time from generation speed, we streamed the Kubernetes prompt three times through each model from the lab VM, timing the first output token and the visible tokens per second after it. The probe also sends one request with effort none to each model:
GPT-6.1 Sol produced 80.5 to 81.1 visible tokens per second on all three runs; GPT-6 Sol produced 158 to 171. Time to first output token was also longer, 7.0 to 12.3 seconds against 5.3 to 6.7, even though GPT-6.1 Sol spent fewer tokens reasoning. An earlier run of the same probe from a workstation gave the same split (80 to 82 against 163 to 174). OpenAI has announced a GPT-6.1 Sol Ultrafast mode for Codex with up to 8x faster generation “in the coming days”. The standard API model we tested streams at the rates above, and interactive tools that stream code to a person will feel it.
Error: Unsupported value: ‘none’ is not supported with the ‘gpt-6.1-sol’ model
Swapping gpt-6-sol for gpt-6.1-sol in a pipeline that sets "effort":"none" returns HTTP 400 with "code": "unsupported_value" and "param": "reasoning.effort". The same request to GPT-6 Sol completes. Map none to low before you change the model ID, or keep latency-critical calls that need zero reasoning on GPT-6 Sol or Luna.
Call GPT-6.1 Sol, GPT-6 Sol and Luna from the API
All three models are live on the Responses API under their plain IDs, with no dated snapshot to pin yet. A minimal call with an explicit effort level:
curl -s https://api.openai.com/v1/responses \
-H "Authorization: Bearer ${OPENAI_API_KEY}" \
-H "Content-Type: application/json" \
-d '{"model":"gpt-6-sol","reasoning":{"effort":"low"},"input":"Give the systemctl command that shows why nginx failed to start. One line, no prose."}' \
| jq '{model, status, effort: .reasoning.effort, text: [.output[] | select(.type=="message") | .content[0].text][0], usage: {input: .usage.input_tokens, output: .usage.output_tokens, reasoning: .usage.output_tokens_details.reasoning_tokens}}'Reasoning tokens are counted inside the output total and billed at the output rate:
{
"model": "gpt-6-sol",
"status": "completed",
"effort": "low",
"text": "systemctl status nginx.service",
"usage": {
"input": 25,
"output": 32,
"reasoning": 21
}
}Swap the model to gpt-6.1-sol for the newer Sol or gpt-6-luna for the cheap tier. Leave out reasoning entirely and all three run at medium. On GPT-6 Sol and Luna, "effort":"none" turns reasoning off completely for classification, extraction or anything behind a strict latency budget; our test call returned zero reasoning tokens. GPT-6.1 Sol starts at low.
Error: Unsupported value: ‘none’ is not supported with the ‘gpt-6-astra’ model
Astra returns the same error as GPT-6.1 Sol, with the same list of accepted values: 'low', 'medium', 'high', 'xhigh', and 'max'. A router that escalates from GPT-6 Sol or Luna to either model has to map none to low when it switches, or the escalation path itself fails on the request.
Caching needs the right mechanics to pay off in an agent loop. To change effort mid-conversation without losing the cached prefix, append a configuration_update input item and leave the request-level reasoning.effort unchanged, because editing that field can rewrite the hidden instructions and break the match. To switch tools on and off, keep the tools list identical and restrict it with allowed_tools instead of adding or removing definitions. Explicit breakpoints (prompt_cache_options.mode set to explicit plus prompt_cache_breakpoint on a content block) let you choose where the cached prefix ends. The minimum cacheable prefix is 1,024 tokens and a cached prefix stays eligible for 30 minutes after its last write or reuse. The prompt caching guide has the full request syntax. Our Astra testing measured a 92% cost drop on a warm cache; GPT-6 Sol gets the same 90% discount on reads, and GPT-6.1 Sol 95%.
Where GPT-6.1 Sol, GPT-6 Sol and Luna are available
In ChatGPT, the Sol models and Luna live only in Work (the agent mode) and Codex, for Plus, Pro, Business, Enterprise and Edu users. The OpenAI launch page lists GPT-6.1 Sol for all of those plans from launch day, while its release notes describe a rollout that starts with Pro; like GPT-6 Sol, it is not in regular Chat conversations. Free and Go users get Luna in the desktop app. In Work and Codex the model picker offers a Default option that blends models and reasoning levels on one slider, or a specific model with its own effort levels. The Codex desktop app keeps a model you select manually, and Codex CLI has no slider, so pass the model and effort you want. Our Codex CLI cheat sheet covers the flags.
Outside OpenAI, GitHub Copilot added GPT-6 Sol and Luna on their launch day: Sol for Pro+, Max, Business and Enterprise, Luna for those plans plus Pro, across VS Code, JetBrains, the Copilot CLI and the cloud agent. OpenRouter lists all three as openai/gpt-6.1-sol, openai/gpt-6-sol and openai/gpt-6-luna at the OpenAI list prices. If you are choosing an agent harness rather than a model, our AI coding agent benchmark for DevOps tested six CLIs on the same tasks.
Which GPT-6 model to route each job to
With four models spanning 100x on price, the useful question is where each request goes. This is how we would split it, based on the OpenAI chart data and the runs above:
| Workload | Model and effort | Why |
|---|---|---|
| IaC, manifests, scripts, code review in batch or CI | GPT-6.1 Sol, medium | 9/9 on our tasks including runtime checks, slightly cheaper than GPT-6 Sol, higher chart scores |
| Hard software engineering, long coding agents | GPT-6.1 Sol, high | 75.2% on DeepSWE, above Astra’s best, at a seventh of Astra’s cost per task; max scored lower |
| Interactive tools where a person watches the stream | GPT-6 Sol, medium | Same pass rate on our tasks at about twice the streaming speed |
| Zero-reasoning calls behind a latency budget | GPT-6 Sol or Luna, effort none | GPT-6.1 Sol and Astra reject none |
| Extraction, classification, summaries, log triage | Luna, medium to high | $0.10/$0.50; at high effort its factual error rate (12.5%) beats GPT-5.6 Sol at medium (15.0%) |
| Generated code or config that ships | Luna only behind an execution check | Its manifests passed every linter and crashed on 3 of 3 deploys |
| Peak computer use, hardest science and business workflows | Astra, high to max, or Opus 5.5 at max | Astra leads OSWorld and Terminal-Bench Science; Opus 5.5 at max leads AutomationBench |
If you are on GPT-6 Sol today, switching the model ID to gpt-6.1-sol costs nothing extra and buys higher scores and cheaper cache reads. Check three things first: no request sets effort none, no Chat Completions call depends on tool calling, and no user-facing stream has a latency budget that half the output speed would break. For the Astra side of this decision, the GPT-6 Astra vs Claude Opus 5 comparison has the numbers.
