Half Price Isn't Half Cost

GPT-6.1 Terra halves the price per token against GPT-6.1 Sol, but per task it saves only 8% to 50%, because it spends more tokens on the same work. OpenAI shipped it on October 26 at $1 input and $5 output per million tokens, half of GPT-6.1 Sol and of the GPT-5.6 Terra it replaces. Against its predecessor, Terra also uses fewer tokens, so per-task savings reach 71% to 85%. Against Sol it uses more: on the Artificial Analysis index at max effort it wrote 130 million output tokens to Sol's 67 million, and on MMMU-Pro it costs $0.012 a task to Sol's $0.013. With six reasoning effort levels and a 272K long-context cliff, the per-token price is the wrong number to plan with. Includes per_task.py, 63 lines that rank every model and effort pair by cost per successful task.

Published 2026-10-30 by Dor Amir on the Nadir blog.

Filed under Routing & Cascades.

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.

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.

ModelInputCached inputOutputPer token vs Terra
GPT-6 Luna$0.10$0.01$0.500.1x
GPT-6.1 Terra$1.00$0.05$5.001x
GPT-6.1 Sol$2.00$0.10$10.002x
GPT-5.6 Terra$2.00$0.20$12.002x to 2.4x
GPT-6 Astra$10.00$1.00$50.0010x
Claude Sonnet 5.5$2.00$0.10$10.002x

USD per million tokens, standard tier.

Four details on the model page matter for the bill more than the headline:

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.

Horizontal bar chart of GPT-6.1 Terra's per-task saving by benchmark. Against GPT-6.1 Sol: Agents' Last Exam at max effort 50% cheaper, Artificial Analysis Intelligence Index at max 44% cheaper, MMMU-Pro 8% cheaper. Against GPT-5.6 Terra: AA Intelligence Index 71% cheaper, Agents' Last Exam 72%, OSWorld 2.1 75%, MMMU-Pro 85%. A dashed line marks the 50% list-price cut.
Horizontal bar chart of GPT-6.1 Terra's per-task saving by benchmark. Against GPT-6.1 Sol: Agents' Last Exam at max effort 50% cheaper, Artificial Analysis Intelligence Index at max 44% cheaper, MMMU-Pro 8% cheaper. Against GPT-5.6 Terra: AA Intelligence Index 71% cheaper, Agents' Last Exam 72%, OSWorld 2.1 75%, MMMU-Pro 85%. A dashed line marks the 50% list-price cut.
BenchmarkTerraSolGPT-5.6 TerraTerra vs SolTerra 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.

Scatter plot of Agents' Last Exam score against cost per task at max reasoning effort, log scale. GPT-6.1 Terra 60.0% at $1.01. GPT-6.1 Sol 58.6% at $2.00. GPT-5.6 Terra 50.7% at $3.58. GPT-6 Astra 59.3% at $7.24. Claude Opus 5.5 63.2% at $8.82.
Scatter plot of Agents' Last Exam score against cost per task at max reasoning effort, log scale. GPT-6.1 Terra 60.0% at $1.01. GPT-6.1 Sol 58.6% at $2.00. GPT-5.6 Terra 50.7% at $3.58. GPT-6 Astra 59.3% at $7.24. Claude Opus 5.5 63.2% at $8.82.

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:

  1. 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.
  2. 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.
  3. 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
Horizontal bar chart of cost per successful task on a synthetic eval run. gpt-6-luna medium $0.013 at 59% pass. gpt-6.1-terra low $0.096 at 69%. gpt-6.1-terra medium $0.152 at 81%. gpt-6.1-sol medium $0.236 at 85%. gpt-6.1-terra max $0.374 at 85%. gpt-5.6-terra medium $0.820 at 67%. The two pairs that clear an 82% floor are highlighted.
Horizontal bar chart of cost per successful task on a synthetic eval run. gpt-6-luna medium $0.013 at 59% pass. gpt-6.1-terra low $0.096 at 69%. gpt-6.1-terra medium $0.152 at 81%. gpt-6.1-sol medium $0.236 at 85%. gpt-6.1-terra max $0.374 at 85%. gpt-5.6-terra medium $0.820 at 67%. The two pairs that clear an 82% floor are highlighted.

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:

  1. Log the effort with every eval row. Without it, Terra at low and Terra at max collapse into one average that describes neither.
  2. Use your own pass criterion. Unit tests, a rubric, a human label. The script only needs a 0 or 1 per attempt.
  3. 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.
  4. 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.
  5. 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 PRICES and 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/).

More on routing & cascades

Pages on this site

Machine-readable summaries of this site: llms.txt and llms-full.txt.