GPT-6.1 Terra is the model that makes this lineup awkward to choose from. OpenAI shipped it on 26 October 2026 at $1 input and $5 output per million tokens, half the price of GPT-6.1 Sol. Sol itself replaced GPT-6 Sol at DevDay on 29 September with the same $2/$10 rates and cached input cut to $0.10. GPT-6 Sol and GPT-6 Luna stay on the price list, so you now route between four cheaper models under GPT-6 Astra.
This page covers the specs, API pricing and OpenAI chart numbers for all four, plus our own DevOps test: Kubernetes, bash and OpenTofu files graded by linters, a behaviour test and real deploys on k3s. Every Terra test below was run on an Ubuntu 26.04 lab VM in October 2026, next to a same-day GPT-6.1 Sol rerun. Our verdict: Terra at high effort matched GPT-6.1 Sol on every check for the same money, and Terra at none works but failed two of three Kubernetes deploys.
Compare GPT-6.1 Sol, Terra and Luna specs
All four 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, and Terra is the only GPT-6.1 model that still lets you switch reasoning off.
| Attribute | GPT-6.1 Sol | GPT-6.1 Terra | GPT-6 Sol | GPT-6 Luna |
|---|---|---|---|---|
| API model ID | gpt-6.1-sol | gpt-6.1-terra | gpt-6-sol | gpt-6-luna |
| Released | 29 September 2026 | 26 October 2026 | 22 September 2026 | 22 September 2026 |
| Positioning (OpenAI) | Near-Astra performance for complex work at a lower cost | Fast, efficient model for visual reasoning, precise computer use and clear, natural writing | Complex coding and agentic workflows | Focused, high-volume tasks |
| Context window | 1,050,000 tokens | 1,050,000 tokens | 1,050,000 tokens | 1,050,000 tokens |
| Max output | 128,000 tokens | 128,000 tokens | 128,000 tokens | 128,000 tokens |
| Knowledge cutoff | 30 April 2026 | 1 June 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 | none, low, medium (default), high, xhigh, max |
| Tool calling on Chat Completions | Responses API only | Responses API only | Only at effort none | Only at effort none |
| Fine-tuning | Not supported | Not supported | Not supported | Not supported |
| Rate limit, Build tier | 5,000 RPM, 1M TPM | 5,000 RPM, 1M TPM | 5,000 RPM, 1M TPM | 5,000 RPM, 2M TPM |
The reasoning ladder is the change that breaks pipelines. GPT-6 Sol, Luna and Terra accept none; GPT-6.1 Sol and Astra do not. The GPT-6.1 Sol model page and the Terra page both say tool calling requires the Responses API, 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 to either 6.1 model. The GPT-6 Sol page offers EU data residency on Standard, Flex and Batch but not Fast, and Luna on all four. The GPT-6.1 Sol and Terra pages list regional processing at a 10% premium without naming EU residency, so check the data residency eligibility guide before you move a regulated workload to either.
Terra now has the newest knowledge cutoff of the family, 1 June 2026, two weeks past Luna. OpenAI has moved all four model pages to usage tiers named Build, Launch and Grow. At Build, every model gets 5,000 requests per minute and Luna gets twice the token rate of the others, so check the page against your own account before you size a batch job.
GPT-6.1 Sol, Terra and Luna pricing
Terra halves the Sol price on every line, input, cache and output alike. GPT-6.1 Sol kept the GPT-6 Sol token rates and only cut cached input in half, which is the line that matters for agent loops.
| Per 1M tokens | GPT-6.1 Sol | GPT-6.1 Terra | GPT-6 Sol | GPT-6 Luna | GPT-6 Astra |
|---|---|---|---|---|---|
| Input | $2.00 | $1.00 | $2.00 | $0.10 | $10.00 |
| Cached input (read) | $0.10 | $0.05 | $0.20 | $0.01 | $1.00 |
| Cache write | $2.50 | $1.25 | $2.50 | $0.125 | $12.50 |
| Output | $10.00 | $5.00 | $10.00 | $0.50 | $50.00 |
| Input / output above 272K prompt tokens | $4.00 / $15.00 | $2.00 / $7.50 | $4.00 / $15.00 | $0.20 / $0.75 | $20.00 / $75.00 |
| Predecessor input / output | $2.00 / $10.00 (GPT-6 Sol) | OpenAI: 50% below GPT-5.6 Terra | $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; Terra also offers a 12-hour cache retention at $2.50 per million written. Cache reads are 5% of input on GPT-6.1 Sol and Terra and 10% on the rest, so a prefix written once and replayed twenty times on either 6.1 model costs a little over two uncached sends.
Half the token price isn’t half the bill. On our DevOps tasks below, Terra at its default medium effort wrote 2.2 times as many reasoning tokens as GPT-6.1 Sol and ended up 30% cheaper, not 50%. The GPT-6 launch had its own 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%.
Against Anthropic, Sol token rates match Claude Sonnet 5.5 ($2/$10), are half of Claude Opus 5.5 ($4/$20) and a fifth of Claude Fable 5.1 ($10/$50). Terra costs half of Sonnet 5.5, the Anthropic model it lines up against on position. Opus 5.5 bills cache hits at $0.20 per million, the same as GPT-6 Sol and four times Terra. 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’s 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.
GPT-6.1 Terra benchmarks: what OpenAI and Artificial Analysis report
OpenAI pitches Terra on speed and price, not on beating Sol. The GPT-6.1 Terra launch post says so directly for coding: “For the most complex coding tasks, GPT-6.1 Sol and GPT-6 Astra remain the better choice.” The numbers it does publish compare Terra mostly with GPT-5.6 Terra, which it replaces:
- Terminal-Bench 4.0 at max effort: 50.3%, against 21.5% for GPT-5.6 Terra
- Agents’ Last Exam at medium: 15 points above GPT-5.6 Terra, on par with Astra at a tenth of its token price
- Terminal-Bench Science 0.1 at max: above GPT-6.1 Sol at lower cost, within five points of Opus 5.5 at under a fifth of the cost
- Factual error rate: 16.7% at low effort (53.6% for GPT-5.6 Terra), 4.3% at max
- Speed: “over three times faster than both GPT-6 Astra and GPT-6.1 Sol” at completing tasks
The launch text gives no DeepSWE, AutomationBench or GDP.pdf figure for Terra, so the Sol table above has no Terra column to slot into. The factual error rate at max (4.3%) lands within a fraction of a point of GPT-6.1 Sol at xhigh (4.1%), which fits the positioning: close on knowledge work, behind on hard code. Like Sol, Terra meets the Critical cybersecurity threshold under the OpenAI Preparedness Framework, so it ships behind the same safeguards.
Artificial Analysis measured Terra at max effort at 48 on its Intelligence Index against 52 for GPT-6.1 Sol at max, at $0.40 per task to run the index against $0.72, per the two model pages. Terra used 130M tokens to get through the index, nearly twice the 67M Sol needed, which is the same verbosity our own runs show at medium. Its throughput measurement was 90.9 output tokens per second against 73.5 for Sol. Simon Willison ran his pelican SVG test at each effort level, and the max-effort pelican took 4 minutes 11 seconds and 11.3 cents. He also quotes an OpenAI engineer’s summary: probably better than Astra and Sol at technical communication, similar on vision and computer use but much faster, and “a bit worse on most other things.” Neither source deploys or executes generated infrastructure files, which is what our test below does.
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’s 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 Claude 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:
The Sol pods sit at Running with zero restarts, while all three Luna pods are in CrashLoopBackOff after three restarts in 75 seconds. The last two log lines name the cause.
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’s 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 can’t 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:
On all three runs GPT-6.1 Sol produced 80.5 to 81.1 visible tokens per second; 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 since added an Ultrafast mode for GPT-6.1 Sol, billed at 6x the Standard rate on the model page. The standard mode 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.
GPT-6.1 Terra vs GPT-6.1 Sol on the same DevOps tasks
We ran Terra through the same three prompts and system prompt, three runs each, at the default medium effort, at high and at none, with GPT-6.1 Sol at medium rerun the same morning as the control. The lab host had no direct OpenAI key this time, so every call went through the OpenRouter Responses endpoint with the provider pinned to OpenAI and fallbacks off. Each response confirmed the served model and the effort level. Costs come from the usage fields at OpenAI list prices, and OpenRouter billed the same amounts. The proxy adds a hop to every call, so compare the latency columns with each other, not with the direct runs above. All 36 files went through the same validators and the same k3s deploy on a fresh Ubuntu 26.04 VM.
| Check (3 runs each) | Terra (medium) | Terra (high) | Terra (none) | GPT-6.1 Sol (medium) |
|---|---|---|---|---|
| Kubernetes: kubeconform -strict | 3/3 valid | 3/3 valid | 3/3 valid | 3/3 valid |
| Kubernetes: deploys and serves HTTP 200 on k3s | 3/3 | 3/3 | 1/3 | 3/3 |
| Bash: shellcheck -S info | 3/3 clean | 3/3 clean | 3/3 clean | 3/3 clean |
| Bash: behaviour test | 3/3 | 3/3 | 2/3 | 3/3 |
| Terraform: tofu validate | 3/3 | 3/3 | 3/3 | 3/3 |
| Terraform: tofu fmt -check | 2/3 | 3/3 | 2/3 | 3/3 |
| Passed every check | 8/9 | 9/9 | 5/9 | 9/9 |
| Total cost, 9 calls | $0.0429 | $0.0626 | $0.0170 | $0.0609 |
| Reasoning tokens, 9 calls | 4,931 | 8,829 | 0 | 2,195 |
| Mean output tokens (k8s / bash / tofu) | 1,091 / 968 / 702 | 1,689 / 1,599 / 788 | 353 / 190 / 494 | 693 / 631 / 609 |
| Mean latency (k8s / bash / tofu) | 13.3s / 11.7s / 8.8s | 19.6s / 18.6s / 9.6s | 4.9s / 3.2s / 8.5s | 10.4s / 13.0s / 7.2s |
Terra at medium cost 30% less than GPT-6.1 Sol, not the 50% the price sheet promises, because it spent 2.2 times as many reasoning tokens on the same prompts. Push it to high and the bill lands on top of Sol’s: $0.0626 against $0.0609 for nine calls, with a clean 9/9. So on this kind of work you’re choosing between Sol at medium and Terra at high for the same money. Sol finished the nine calls in 92 seconds, Terra at high in 144. Even at medium Terra took 101 seconds in total, so the “three times faster” claim in the launch post did not show up on single-file generation. That claim is about finishing agentic tasks, where fewer turns matter more than per-call time.
The Sonnet 5.5 release test used these exact prompts and graders, so the cost side compares directly even though it ran on another day. Sonnet 5.5 passed 9/9 at medium for $0.0665 and at its high default for $0.1230. Terra at high matched that pass rate for about half the Sonnet default bill, and Terra at medium came in 35% under Sonnet at medium with one formatting miss. If GPT-6.1 Terra vs Claude Sonnet 5.5 is your decision for config generation, Terra wins on cost, and its only miss at medium was the formatting slip below.
Terra’s one miss at medium: tofu fmt -check
The first medium run produced valid HCL that tofu validate accepted, then failed tofu fmt -check on one line in the security group egress block. The ipv6_cidr_blocks argument does not line up with the = signs above it:
egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
ipv6_cidr_blocks = ["::/0"]
}That’s cosmetic, and tofu fmt fixes it in place, but a CI job that gates on fmt -check fails the merge request. Run tofu fmt on model output before the check rather than asking the model to try again. The same line broke formatting in one of the none runs too, while no Sol file in any of our runs failed formatting.
The manifests also show where Terra saves effort. Two of the three medium runs skipped the volume mounts and generated an nginx config in the container start command that moves every temp path to /tmp. Both deployed and served HTTP 200, but none of the three medium manifests set readOnlyRootFilesystem, while all three Sol manifests did. At high effort, two of three Terra manifests set it. On the bash side, all three high-effort scripts wrote dumps into the current directory, which under cron is wherever cron starts, the same habit GPT-6 Sol and Luna showed at launch.
Does GPT-6.1 Terra accept reasoning effort none?
Yes. GPT-6.1 Terra accepts "effort":"none" and returns zero reasoning tokens, unlike GPT-6.1 Sol and Astra, which reject it with HTTP 400. This is the request we sent, through OpenRouter because that’s the route this lab had; against the OpenAI API, drop the openai/ prefix and use https://api.openai.com/v1/responses with your OpenAI key:
curl -s https://openrouter.ai/api/v1/responses \
-H "Authorization: Bearer ${OPENROUTER_API_KEY}" \
-H "Content-Type: application/json" \
-d '{"model":"openai/gpt-6.1-terra","reasoning":{"effort":"none"},"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}}'The response completes with the effort echoed back as none and a reasoning count of zero:
{
"model": "openai/gpt-6.1-terra",
"status": "completed",
"effort": "none",
"text": "systemctl status nginx.service",
"usage": {
"input": 25,
"output": 9,
"reasoning": 0
}
}The same request with openai/gpt-6.1-sol fails, but OpenRouter answers it itself with "Reasoning is mandatory for this endpoint and cannot be disabled." and HTTP 400, not the OpenAI unsupported_value error shown earlier. If you match on error text in a router, match both. Speed is the reason to use none: on three streamed runs of the Kubernetes prompt, the first output token arrived after 0.9 to 1.0 seconds at none against 5.5 to 7.5 seconds at medium, and the whole call finished in about 5 seconds instead of 9 to 11.
Quality is what it costs. At none, Terra passed 5 of 9 checks, and two of its three Kubernetes manifests passed kubeconform -strict and then failed on the cluster. One crash-looped next to the healthy medium manifest:
The medium manifest runs three pods with zero restarts, the none manifest has all three in CrashLoopBackOff after 75 seconds, and the log of one crashed pod names the cause in its last line.
Error: “pid” directive is duplicate in /etc/nginx/nginx.conf:6
The first none manifest tried to move the nginx PID file somewhere a non-root user can write by passing it on the command line. The stock nginx:1.27-alpine config already sets pid, and nginx refuses to start with two, so every pod exits on start and Kubernetes backs off. These are the container args, verbatim:
args:
- -g
- "daemon off; pid /tmp/nginx.pid;"The fix is the one the medium runs used: an emptyDir over /var/run (and /var/cache/nginx) and no pid override, or a full config of your own passed with -c. The third none manifest failed more quietly. It mounted an emptyDir over /etc/nginx/conf.d, which hides default.conf, so nginx started with nothing listening on port 80. The pods showed Running, the liveness probe kept killing them, and the Service never answered. The failed bash script broke on a missing directory: it honoured BACKUP_DIR but never ran mkdir -p, so mktemp failed with No such file or directory on the first real run.
Use Terra at none the way you would use Luna at none: classification, extraction, short answers behind a latency budget. Do not use it to write files that ship unless a deploy or execution step sits in the loop.
Call GPT-6.1 Sol, Terra and Luna from the API
All four 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, gpt-6.1-terra for half the Sol price or gpt-6-luna for the cheap tier. Leave out reasoning entirely and all four run at medium. On GPT-6 Sol, Luna and GPT-6.1 Terra, "effort":"none" turns reasoning off completely for classification, extraction or anything behind a strict latency budget; our test calls returned zero reasoning tokens on all three. GPT-6.1 Sol starts at low. Terra also takes tools, but only through the Responses API, so a Chat Completions integration that calls functions should move before it switches.
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, Luna or Terra 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 and Terra 95%.
Where GPT-6.1 Sol, Terra 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 isn’t 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.
Terra launched on OpenAI, GitHub Copilot and Amazon Bedrock on the same day. These are the surfaces with a primary source behind them, as of 27 October 2026:
- ChatGPT Work and Codex: Plus, Pro, Enterprise and Edu
- GitHub Copilot, generally available: Pro, Pro+, Max, Business and Enterprise
- Amazon Bedrock, generally available:
openai.gpt-6.1-terra - OpenRouter:
openai/gpt-6.1-terraat the OpenAI list price
In Codex, OpenAI says a plan’s usage goes substantially further on Terra than on GPT-6.1 Sol or Astra, which makes it the obvious default for long sessions on a Plus plan. The launch post doesn’t mention Free, Go or Business for Terra. The GitHub changelog doesn’t list Copilot Free, and it bills Terra at provider list pricing under usage-based billing. It covers VS Code, Visual Studio, JetBrains, Xcode, Eclipse, the Copilot CLI, the cloud agent, the Copilot app, github.com and GitHub Mobile, with a gradual rollout.
Bedrock is the one to read carefully. On the bedrock-mantle endpoint, openai.gpt-6.1-terra runs In-Region in us-east-1 only. On bedrock-runtime there is no In-Region option: you call it through the us.openai.gpt-6.1-terra profile from the US and Canadian regions, or global.openai.gpt-6.1-terra from most EU and APAC regions as well. The Bedrock model card prices the global profile at the OpenAI list rate ($1 input, $5 output) and In-Region and us. calls at 10% more ($1.10 and $5.50), with only the Standard tier offered. AWS also says ChatGPT Work and Codex can be configured to use the Bedrock model, and that one output token burns ten tokens of quota on bedrock-runtime. We did not run Terra on Bedrock.
For the older models, 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 four as openai/gpt-6.1-sol, openai/gpt-6.1-terra, openai/gpt-6-sol and openai/gpt-6-luna at the OpenAI list prices. If you’re 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 five 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, or GPT-6.1 Terra, high | Both 9/9 on our tasks including runtime checks, for the same money; Sol finished faster and set readOnlyRootFilesystem every time |
| High-volume generation with a validator after it | GPT-6.1 Terra, medium | 8/9 (one tofu fmt miss) at 30% under GPT-6.1 Sol and 35% under Sonnet 5.5 at medium |
| Writing, docs, vision and computer use | GPT-6.1 Terra, medium | OpenAI positioning; on par with Astra on Agents’ Last Exam at a tenth of the token price |
| 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 | Luna, GPT-6.1 Terra or GPT-6 Sol, effort none | GPT-6.1 Sol and Astra reject none; Terra at none reached the first token in about 1 second but failed 4 of 9 file checks |
| 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’re 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.
Terra replaces Sol when the bill matters more than the hardest tasks. For config and script generation that a pipeline validates anyway, Terra at medium does the job for 30% less, and Terra at high buys back the last check for the price of Sol. Keep GPT-6.1 Sol for long coding agents and hard software engineering, where it holds the chart lead and OpenAI itself steers you away from Terra. Terra replaces Luna only where Luna’s output fails: Luna is ten times cheaper and still the right call for extraction and triage, but its manifests crashed 3 of 3 deploys at launch while Terra’s medium manifests passed 3 of 3.
