TL;DR.
OpenAI shipped GPT-6.1 Terra on October 26 at $1 per million input tokens and $5 per million output, half of GPT-6.1 Sol and half of the GPT-5.6 Terra it replaces. That is a price per token. What you pay for is a task, and the per-task numbers OpenAI and Artificial Analysis published the same week don't move by half.
- Against Sol, Terra saves between 8% and 50% per task, not 50%. On Agents' Last Exam at max effort it costs $1.01 a task against Sol's $2.00. On the Artificial Analysis index it's $0.40 against $0.72, 44% less, because Terra wrote 130 million output tokens to Sol's 67 million. On MMMU-Pro it's $0.012 against $0.013: 8%.
- Against GPT-5.6 Terra, it saves 71% to 85% per task, more than the price cut. The new model uses fewer tokens to finish the same work, so the saving compounds: $3.58 to $1.01 on Agents' Last Exam, $4.76 to $1.19 on OSWorld 2.1.
- Reasoning effort is now a second price list. Terra takes six effort levels, from
nonetomax. At max it needs about twice the output tokens of Sol on the AA index. Artificial Analysis rates Terra at low and medium effort, not max, as Pareto-optimal. - The cheapest model per token isn't always cheapest per success. On a synthetic eval, Sol at medium effort cost 37% less per successful task than Terra at max, with the same pass rate.
- Below is per_task.py, 63 lines that price an eval log per successful task across every model and effort pair, with OpenAI's 272K long-context rule, and pick the cheapest pair above your quality floor.
Prices are from OpenAI's GPT-6.1 Terra model page, retrieved October 30, 2026. Benchmark scores and costs per task are OpenAI's launch figures as reported by InfoWorld, and Artificial Analysis figures as reported by The Daily Brief. They are vendor- or third-party-reported and we have not reproduced them. The eval in the tutorial is synthetic. No figure here comes from Nadir customer data.
What changed on October 26.
GPT-6.1 Terra replaces GPT-5.6 Terra, the last Terra-tier model still on the 5.6 generation. It sits in the middle of OpenAI's four classes: Luna, Terra, Sol and Astra, cheapest to most capable. OpenAI pitches it for visual reasoning, computer use and writing, and still points to Sol or Astra for the hardest coding and research work.
| Model | Input | Cached input | Output | Per token vs Terra |
|---|---|---|---|---|
| GPT-6 Luna | $0.10 | $0.01 | $0.50 | 0.1x |
| GPT-6.1 Terra | $1.00 | $0.05 | $5.00 | 1x |
| GPT-6.1 Sol | $2.00 | $0.10 | $10.00 | 2x |
| GPT-5.6 Terra | $2.00 | $0.20 | $12.00 | 2x to 2.4x |
| GPT-6 Astra | $10.00 | $1.00 | $50.00 | 10x |
| Claude Sonnet 5.5 | $2.00 | $0.10 | $10.00 | 2x |
USD per million tokens, standard tier.
Four details on the model page matter for the bill more than the headline:
- Six effort levels.
none,low,medium(the default),high,xhighandmax. Terra acceptsnone; Sol does not let you turn reasoning off. - A 272K cliff. Above 272,000 input tokens, the whole request is billed at 2x input and cache rates and 1.5x output. The context window is 1,050,000 tokens, so most of the window sits above the cliff. We priced the same rule on GPT-5.6 Codex in The 272K Cliff.
- Cache writes cost extra. Writes are $1.25 per million for 30-minute retention and $2.50 for 12 hours, so a prefix that isn't reused costs more than an uncached one.
- Same price modifiers as the rest of the lineup. Batch and Flex are 50% off, regional processing adds 10%, and Fast mode is 2x Standard.
Half price, unequal savings.
OpenAI's launch charts and the Artificial Analysis run both report cost per task, so the price cut can be checked against what a finished task costs.
| Benchmark | Terra | Sol | GPT-5.6 Terra | Terra vs Sol | Terra vs 5.6 Terra |
|---|---|---|---|---|---|
| Agents' Last Exam, max effort | $1.01 (60.0%) | $2.00 (58.6%) | $3.58 (50.7%) | -50% | -72% |
| AA Intelligence Index, max | $0.40 (48) | $0.72 (52) | $1.40 | -44% | -71% |
| OSWorld 2.1 | $1.19 (74.2%) | n/a | $4.76 (57.1%) | n/a | -75% |
| MMMU-Pro | $0.012 (85.5%) | $0.013 (86.3%) | $0.079 (81.7%) | -8% | -85% |
Cost per task in USD, score in brackets. AA is Artificial Analysis.
The two comparisons break in opposite directions, and for the same reason: tokens per task.
Against its predecessor, Terra wins twice. It's cheaper per token and it gets to the answer in fewer tokens, so per-task savings land at 71% to 85%, well past the 50% list cut. If you are on GPT-5.6 Terra today, this is the rare upgrade that cuts cost more than the price sheet says.
Against Sol, the token gap eats part of the discount. On the Artificial Analysis index at max effort, Terra wrote 130 million output tokens to Sol's 67 million. Twice the output tokens at half the price would cancel out on output; the input side keeps part of the discount, and the measured saving is 44%. On MMMU-Pro, a visual reasoning benchmark, Sol costs $0.013 a task to Terra's $0.012, and scores 0.8 points higher. If that is your workload, the "half price" model is 8% cheaper.
None of this makes Terra a bad deal. It makes the per-token price the wrong number to plan with. The ratio that predicts your bill is cost per task, and it differs by workload even between two models from the same vendor released a month apart.
Effort is the second price list.
The bigger knob is inside a single model. Terra at max and Terra at low are, for billing purposes, different products.
OpenAI didn't publish cost per task at each effort level, but it published enough to see the spread. At medium effort, it says Terra scores 15 points above GPT-5.6 Terra on Agents' Last Exam at about a third of the cost; at max, the chart above puts it at $1.01 a task. Its error-inducing-prompt benchmark shows what the extra effort buys: errors fall from 16.7% at low effort to 4.3% at max. And Artificial Analysis's count shows what it costs: at max, Terra wrote nearly twice Sol's output tokens to run the same index. Whether 12 points fewer errors are worth that depends entirely on what an error costs you.
On the launch chart, Terra sits at the efficient corner: within 3.2 points of Claude Opus 5.5 at about one ninth of the cost per task, and above Astra at one seventh. That's at max effort, the setting where, by Artificial Analysis's count, Terra spends the most tokens. Their own Pareto frontier puts Terra at low and medium effort on the line, not max.
Two numbers from outside the benchmarks set the scale. OSWorld 2.1, the computer-use benchmark OpenAI leads with, has Claude Sonnet 5.5 at 83.9% for $5.74 a task, against Terra's 74.2% for $1.19. Per successful task, that's $1.60 for Terra and $6.84 for Sonnet, if failures can be retried. And Greyhound Research's Sanchit Vir Gogia, quoted by InfoWorld, put the limit of the whole exercise plainly: "Cheaper inference improves one component of agent economics." In his illustrative coding workload, 5.4 extra seconds of human review per task erased the inference saving. A failed computer-use run that clicks the wrong button can cost more than any token line.
The effort matrix most teams skip.
A model launch used to be one decision: switch or don't. With six effort levels per model and four model classes, it's a matrix, and most teams test one cell: the new model at the default effort, against the old model at the default effort.
Three things go wrong with that:
- Default is medium. If your old integration ran GPT-5.6 Terra at
high, swapping the model string without setting effort changes two things at once. You won't know which moved quality. - Max-effort benchmarks flatter the wrong cell. Launch charts are often shown at max effort, which is the cell where Terra's token count runs highest. Your production setting probably isn't max.
- Long-context traffic re-prices silently. Agents that carry screenshots and tool history drift past 272K input tokens. Every such request bills at 2x input on the whole request, on Terra and GPT-5.6 Terra alike. A higher effort level that adds turns pushes more requests over the line.
The fix is to price the cells, not the models: run your eval at two or three effort levels per candidate, and compare cost per successful task.
Tutorial: per_task.py.
per_task.py reads an eval log with one row per attempt: model, effort, task, whether it passed, input tokens, cached input tokens and output tokens (reasoning included, as OpenAI reports them in usage). It prices each attempt at list price, applies the 272K rule, and ranks every model and effort pair by cost per task that passed.
"""per_task.py: price an eval run per successful task, not per token.
Reads a CSV of eval attempts (model, effort, task, passed, input_tokens,
cached_tokens, output_tokens; output includes reasoning tokens), prices every
attempt at list price, and ranks each model and effort pair by cost per task
that passed. Then picks the cheapest pair that clears your pass-rate floor.
"""
import csv
import sys
from collections import defaultdict
# USD per million tokens: input, cached input, output. OpenAI list, Oct 26, 2026.
PRICES = {
"gpt-6-luna": (0.10, 0.01, 0.50),
"gpt-6.1-terra": (1.00, 0.05, 5.00),
"gpt-6.1-sol": (2.00, 0.10, 10.00),
"gpt-5.6-terra": (2.00, 0.20, 12.00),
"gpt-6-astra": (10.00, 1.00, 50.00),
}
# Over 272K input tokens, the whole request bills at 2x input and cache, 1.5x
# output. Listed on both Terra model pages; check the page for any model you add.
LONG_CONTEXT = {"gpt-6.1-terra", "gpt-5.6-terra"}
CLIFF = 272_000
def cost(model, inp, cached, out):
p_in, p_cache, p_out = PRICES[model]
k_in, k_out = (2.0, 1.5) if model in LONG_CONTEXT and inp > CLIFF else (1.0, 1.0)
return ((inp - cached) * p_in * k_in + cached * p_cache * k_in
+ out * p_out * k_out) / 1e6
def main(path, floor=0.75):
arms = defaultdict(lambda: {"n": 0, "passed": 0, "usd": 0.0, "out": 0, "cliff": 0})
for r in csv.DictReader(open(path, newline="")):
a = arms[(r["model"], r["effort"])]
inp, cached, out = int(r["input_tokens"]), int(r["cached_tokens"]), int(r["output_tokens"])
a["n"] += 1
a["passed"] += int(r["passed"])
a["usd"] += cost(r["model"], inp, cached, out)
a["out"] += out
a["cliff"] += r["model"] in LONG_CONTEXT and inp > CLIFF
print(f"{'model / effort':<24}{'pass':>6}{'$/attempt':>11}{'$/success':>11}"
f"{'out tok':>9}{'>272K':>7}")
ranked = sorted(arms.items(), key=lambda kv: kv[1]["usd"] / max(kv[1]["passed"], 1))
for (model, effort), a in ranked:
rate = a["passed"] / a["n"]
print(f"{model + ' / ' + effort:<24}{rate:>6.0%}{a['usd'] / a['n']:>11.3f}"
f"{a['usd'] / max(a['passed'], 1):>11.3f}{a['out'] // a['n']:>9,}"
f"{a['cliff'] / a['n']:>7.0%}")
ok = [(k, a) for k, a in ranked if a["passed"] / a["n"] >= floor]
if not ok:
print(f"\nno pair clears a {floor:.0%} pass rate")
return
(model, effort), a = ok[0]
print(f"\ncheapest pair at >= {floor:.0%} pass: {model} / {effort}, "
f"${a['usd'] / a['passed']:.3f} per successful task")
if __name__ == "__main__":
main(sys.argv[1], float(sys.argv[2]) if len(sys.argv) > 2 else 0.75)
On a synthetic log of 1,800 attempts, 300 tasks for each of six pairs, python per_task.py evals.csv 0.82 prints:
model / effort pass $/attempt $/success out tok >272K
gpt-6-luna / medium 59% 0.008 0.013 10,090 0%
gpt-6.1-terra / low 69% 0.067 0.096 7,224 2%
gpt-6.1-terra / medium 81% 0.124 0.152 16,662 4%
gpt-6.1-sol / medium 85% 0.200 0.236 13,931 0%
gpt-6.1-terra / max 85% 0.320 0.374 48,354 14%
gpt-5.6-terra / medium 67% 0.546 0.820 33,812 7%
cheapest pair at >= 82% pass: gpt-6.1-sol / medium, $0.236 per successful task
The data is made up, but the shape is the one the published numbers point to. At an 80% floor, Terra at medium wins at $0.152. Raise the floor to 82%, and the cheapest way to get there isn't Terra at max: it's Sol at medium, at twice the price per token and 37% less per success, because Terra at max writes 3.5x the output tokens and pushes 14% of attempts over the 272K line.
How to adapt it:
- Log the effort with every eval row. Without it, Terra at low and Terra at max collapse into one average that describes neither.
- Use your own pass criterion. Unit tests, a rubric, a human label. The script only needs a 0 or 1 per attempt.
- Count cached tokens separately. Agent loops are mostly cache reads at $0.05 per million on Terra. Pricing them at the input rate overstates Terra's cost 20x on that line.
- Add the cost of a failure. If a failed task costs a human ten minutes, add it per failure before ranking. That one line usually decides between the two highlighted bars.
- Rerun it when a price changes. Gemini 4 Argon doubles on December 1 and the gpt-5 family retires December 11, both on the Q4 repricing calendar. Add rows to
PRICESand the ranking updates.
Where Nadir fits.
per_task.py finds the cheapest cell for a workload. Real traffic isn't one workload: a support queue or a coding agent mixes requests that Luna finishes with requests that need Sol, and one cell for all of them overpays on the easy ones or fails the hard ones.
Nadir makes that decision per request. Send model="auto" and Nadir picks the model for each prompt from the set you've configured, against the quality floor you set on the API key, and each response reports which model served it and what it cost. That's the per-request version of the matrix above, without running every cell on every prompt. If you'd rather keep your own client and effort settings, POST /v1/bucket returns simple, medium or complex for a prompt, and you map each bucket to a model and effort pair from your own per_task.py results: Luna for simple, Terra at medium for medium, Sol for complex, say.
When Terra launched, the expensive part wasn't changing the model string. It was finding out how much traffic could move to it, and at what effort, without anyone seeing a worse answer. Observe mode serves exactly the model you asked for and records what routing would have chosen, so you can compare that against your own numbers before you switch. With your own provider keys, Nadir charges no fee on any plan, and the provider bills you directly. Savings depend on your workload, and nothing in this post forecasts yours.
Start with a free key, or run per_task.py on your last eval first and see which cell you're paying for.
Conclusion.
GPT-6.1 Terra halves the price per token. Per task, that becomes anywhere from an 8% to an 85% saving, depending on which model you compare it to and what the work is. If you are on GPT-5.6 Terra, move: the new model is cheaper per task by more than its price cut. If you are on Sol, test before you switch, because Terra's extra tokens at high effort eat into the discount, and on some workloads almost all of it. In both cases, test at the effort you'll actually run, price cached tokens and the 272K cliff, and rank by cost per successful task. The per-token price is where the decision starts, not where it ends.
GPT-6.1 Terra prices, effort levels, context limits, the 272K rule and the Batch, Flex, regional and Fast modifiers are from OpenAI's model page, retrieved October 30, 2026. GPT-6.1 Sol, GPT-6 Luna, GPT-6 Astra and Claude Sonnet 5.5 prices are as reported by InfoWorld on October 27, 2026; GPT-5.6 Terra prices as reported by The Daily Brief on October 26. Agents' Last Exam, OSWorld 2.1, MMMU-Pro and error-rate figures are OpenAI's launch figures as reported by InfoWorld and Let's Data Science; the medium-effort Agents' Last Exam comparison is OpenAI's, as reported by DataCamp. Artificial Analysis index scores, output tokens and costs to run are as reported by The Daily Brief. None of these were independently reproduced. The synthetic eval and its output are ours and are an illustration, not a measurement. Sources: [OpenAI, GPT-6.1 Terra model page](https://developers.openai.com/api/docs/models/gpt-6.1-terra). [InfoWorld, "OpenAI bets on AI economics with lower-cost GPT-6.1 Terra," October 27, 2026](https://infoworld.com/article/4241006/openai-bets-on-ai-economics-with-lower-cost-gpt-6-1-terra.html). [The Daily Brief, "GPT-6.1 Terra Costs Half of Sol per Token, Scores 4 Points Lower," October 26, 2026](https://www.beri.net/article/gpt-6-1-terra-launch-pricing-1-5-artificial-analysis-vs-gpt-6-1-sol-computer-use-reasoning-effort-migration). [Let's Data Science, GPT-6.1 Terra benchmark coverage](https://letsdatascience.com/blog/gpt-6-1-terra-beats-openai-flagship-claude-still-leads). [DataCamp, "GPT-6.1 Terra: Benchmarks, Pricing and Access"](https://www.datacamp.com/blog/gpt-6-1-terra). [9to5Mac, "OpenAI upgrades ChatGPT and Codex with new GPT-6.1 Terra model," October 26, 2026](https://9to5mac.com/2026/10/26/openai-upgrades-chatgpt-and-codex-with-new-gpt-6-1-terra-model/).