GPT-6.1 Terra vs Opus 5.5: a quarter of the price per token, but should you swap Claude out of your agent?

OpenAI just shipped a model that costs a quarter of Opus 5.5 per token and claims it more than doubled terminal performance. It's GPT-6.1 Terra, released on October 26. And everyone running agents on Claude is asking the same question: GPT-6.1 Terra vs Opus 5.5, is it worth switching?

Thing is, we've seen this movie before.

Back in July, the previous Terra burned 2.6x more tokens than Sol to pass fewer tasks. Cheap per token, expensive per task.

Do the numbers add up this time? Partly. In this post you'll see where Terra 6.1 sits in OpenAI's lineup, the price-per-task (not per-token) comparison with Opus 5.5, what's still just lab numbers, and which use case actually justifies the switch.

TL;DR

• What it is: the mid tier of the GPT-6.1 family, focused on computer use, vision and writing. Model id gpt-6.1-terra, 1.05M token context, cutoff on June 1, 2026.
• Price: US$ 1 input / US$ 0.05 cache / US$ 5 output per million tokens. Half of GPT-6.1 Sol. A quarter of Opus 5.5 (US$ 4 / US$ 20).
• OpenAI's number: 50.3% on Terminal-Bench 4.0 at max effort, vs 21.5% for GPT-5.6 Terra. Opus 5.5 reported 66.4% on the same benchmark, according to Anthropic.
• What's missing: nobody has reproduced an independent benchmark of GPT-6.1 Terra yet. Everything circulating is OpenAI's own numbers.
• Short verdict: for computer use and volume, test Terra now. For coding agents on long tasks, Opus 5.5 is still ahead, and OpenAI itself says so.

What GPT-6.1 Terra is and where it sits between Luna, Sol and Astra

OpenAI has four tiers today. From cheapest to most expensive, per million tokens (Let's Data Science):

GPT-6.1 Sol came out on September 29, at DevDay, promising near-Astra performance at a fifth of the price (AI Weekly). Terra lands four weeks later at half of Sol's price.

The official positioning is clear: Terra is for "fast, capable computer use at scale". Filling out forms, entering invoices into accounting systems, reading technical drawings, automating repetitive desktop work (BleepingComputer). And OpenAI itself still recommends Sol or Astra for more complex code.

Remember that sentence. It'll come back.

The technical details that matter if you're integrating it (Developers Digest):

• Context: 1.05M input tokens, up to 128k output.
• Effort: none, low, medium (default), high, xhigh, max.
• Tools: tool calling only through the Responses API, with computer use, MCP, skills, hosted shell, apply patch and tool search.
• Long prompts cost more: requests above 272k input tokens pay 2x on input and cache and 1.5x on output, for the whole request.
• Batch and Flex: 50% off.
• Codex CLI: requires version 0.159.0 or later (AI Weekly).

And a detail few people mentioned: Terra was rated "Critical" for cybersecurity under OpenAI's Preparedness Framework, so it inherits the safeguards built for Astra (DataCamp). If your agent does offensive security, pentesting or malware analysis, expect more refusals and more monitoring.

Now, notice the pattern. Every week there's a new chart saying model X is N times cheaper than model Y. People who depend on tools switch models with every chart. People with their own evals switch when the numbers check out on their own repo, and building that eval alongside people who run agents in production is everyday life at the Clã Beer and Code.

Price per token vs price per task: GPT-6.1 Terra vs Opus 5.5 side by side

Per token, there's no contest:

Opus 5.5 prices are from Anthropic's announcement, which we broke down in the post on GPT-6 Sol, Luna and Opus 5.5.

A quarter across the board, including cache read, which is the line that drives the bill in agentic sessions.

But price per token is the wrong metric. Agents don't bill per token. Agents bill per solved task. And that's where three variables the table doesn't show come in: how many tokens the model spends per attempt, how many attempts it needs to get it right, and how much each failure costs.

OpenAI knows this, which is why the chart it picked to compare against Opus 5.5 is cost per task. On Agents' Last Exam, a benchmark of agents doing computer work, at max effort (Let's Data Science):

That's where the "about 9x cheaper per task" and "more than 3x more token-efficient" that OpenAI is using in its marketing come from (DataCamp).

Notice something: GPT-5.6 Terra cost US$ 3.58 per task. 6.1 costs US$ 1.01, with a higher score. In other words, the problem we pointed out in July (cheap tier burning tokens) seems to have actually been tackled. At least on this benchmark.

The math the chart doesn't do

Cost per attempt isn't cost per solved task. If the model gets it wrong, you run it again, or a dev reviews and fixes it. You can model that in ten lines:

def custo_por_tarefa_resolvida(custo_tentativa, taxa_sucesso, custo_falha=0.0):
    """
    custo_tentativa: US$ spent on tokens in one agent run
    taxa_sucesso:    fraction of runs that solve the task (0 to 1)
    custo_falha:     US$ of human time to detect/discard each failure
    """
    tentativas = 1 / taxa_sucesso          # expected runs until success
    falhas = tentativas - 1
    return tentativas * custo_tentativa + falhas * custo_falha


# Numbers from OpenAI's chart (Agents' Last Exam, max effort)
print(custo_por_tarefa_resolvida(1.01, 0.600))  # Terra: ~US$ 1.68
print(custo_por_tarefa_resolvida(8.82, 0.632))  # Opus 5.5: ~US$ 13.96

In computer use, even adding US$ 5 of human review per failure, Terra comes out at ~US$ 5 per solved task vs ~US$ 17 for Opus. The advantage holds.

Now run the same exercise for code. This one is hypothetical, because there's no published cost per task for either model on Terminal-Bench 4.0. Take the reported success rates (50.3% for Terra per OpenAI, 66.4% for Opus per Anthropic) and assume the 9x cost-per-attempt ratio holds: Terra at US$ 1, Opus at US$ 9.

for custo_falha in (0, 5, 24, 50):
    terra = custo_por_tarefa_resolvida(1.0, 0.503, custo_falha)
    opus = custo_por_tarefa_resolvida(9.0, 0.664, custo_falha)
    print(f"falha=US${custo_falha:>2}  terra=US${terra:6.2f}  opus=US${opus:6.2f}")

# falha=US$ 0  terra=US$  1.99  opus=US$ 13.55
# falha=US$ 5  terra=US$  6.93  opus=US$ 16.08
# falha=US$24  terra=US$ 25.70  opus=US$ 25.70
# falha=US$50  terra=US$ 51.39  opus=US$ 38.86

The break-even point lands around US$ 24 per failure. Above that, the more expensive model ends up cheaper.

And US$ 24 is not much. It's about 20 minutes of a senior dev looking at a PR the agent delivered broken. If your coding agent opens PRs someone has to review, the cost of a failure almost certainly exceeds that.

Analyst Sanchit Vir Gogia, from Greyhound Research, raised the same warning: in one of his examples, 5.4 extra seconds of human review were already enough to wipe out the inference savings (Let's Data Science). Tokens are the cheap part of the system. Humans aren't.

What OpenAI measures (Terminal-Bench 4.0, computer use) and what nobody has reproduced yet

Let's separate lab data from independent data. Spoiler: today, October 31, pretty much everything is lab data.

What OpenAI reported:

• Terminal-Bench 4.0 (max effort): 50.3%, vs 21.5% for GPT-5.6 Terra (BleepingComputer).
• Agents' Last Exam (medium effort): 15 points above GPT-5.6 Terra, at about a third of the cost. On par with GPT-6 Astra at a tenth of the price per token.
• OSWorld 2.1: 74.2% at US$ 1.19 per task, vs 57.1% for GPT-5.6 Terra (Let's Data Science).
• MMMU-Pro (vision): 85.5%, right behind Sol (86.3%) and Astra (86.7%).
• Error rate on prompts designed to induce errors: dropped from 53.6% to 16.7% at low effort. At max, 4.3%.
• Speed: more than 3x faster than Sol and Astra on the same tasks.
• Terminal-Bench-Science 0.1: within 5 points of Opus 5.5 at less than a fifth of the estimated cost (DataCamp).

What this doesn't tell you:

First, on Terminal-Bench 4.0, Opus 5.5 reported 66.4% in Anthropic's announcement. That's 16 points above Terra. But heads up: one number came from OpenAI and the other from Anthropic, each with its own harness. You can't compare them directly; they only work as an order of magnitude.

Second, OpenAI picked which rivals showed up in each chart. In the computer use chart (OSWorld 2.1), the one in the lead is Claude Sonnet 5.5, with 83.9% at US$ 5.74 per task. Opus isn't there. Josef Waples, from DataCamp, called the comparison with Opus "a bit artificial or selective", because Terra's natural price rival is Sonnet 5.5 (US$ 2 / US$ 10), not Opus.

Third: nobody has reproduced it yet. Artificial Analysis posted on X that Terra is smarter than its predecessor at less than a third of the cost, but there's no full report published. No CodeRabbit, no third-party suite running real coding tasks. It was exactly a test like that which exposed GPT-5.6 Terra in July.

So treat the numbers above as a hypothesis. A well-grounded one, but a hypothesis.

Terra vs Terra Pro: when to pay the difference

Three flavors showed up on OpenRouter: openai/gpt-6.1-terra, openai/gpt-6.1-terra-pro and :batch variants. The European route via Azure lists the first two at US$ 1.20 input and US$ 6 output (OpenRouter), about 20% above OpenAI's list price, which is the cost of keeping data inside the EU.

What is Terra Pro? Time to be honest: OpenAI didn't detail Terra Pro in the announcement, and the OpenRouter page has no description at all. Pricing aggregators list Pro at the same per-token price as base Terra (LM Market Cap).

If it follows the pattern of GPT-5.6's Pro mode, which runs several agents in parallel, each on its own, and picks the best result (as we explained here), the difference isn't in the price table. It's in consumption: more runs per request, more tokens per task. That's my inference, not documentation.

The rule of thumb:

• Base Terra as the default. Effort medium first, and only go up if the eval asks for it.
• Terra Pro only after measuring, and only on tasks where being wrong is expensive. If Pro doubles consumption to gain a few points, it falls into the same math as Sol Ultra: beautiful until the bill arrives.
• Batch (50% off) for everything that doesn't need a real-time response: backlog classification, document extraction, overnight triage. Terra in batch comes out at US$ 0.50 / US$ 2.50, edging into Luna territory with a lot more capability.

Verdict by use case: coding agent, computer use, cheap volume

Should you swap Claude out of your agent? Depends on which agent.

And there's the cost nobody puts in the spreadsheet: migration. Swapping Opus for Terra isn't swapping a string. Terra's tool calling requires OpenAI's Responses API, the tool format changes, caching behavior changes, effort has a different scale. If your agent has already been tuned for Opus 5.5 (and it has four breaking changes of its own), you'll be rewriting prompts, re-evaluating and retesting.

The grown-up move isn't to switch. It's to route. Opus 5.5 on tasks where failure is expensive. Terra on computer use and volume tasks, where failure is cheap and throughput matters. A simple router by task type already captures most of the savings without betting the whole agent on a benchmark nobody has reproduced.

Limitations and caveats

Every benchmark here is from a lab. Terra's numbers are OpenAI's. Opus 5.5's are Anthropic's. The cost-per-task comparison is OpenAI's, on a benchmark and set of rivals it chose.

Lab A's Terminal-Bench is not lab B's Terminal-Bench. Harness, timeout and effort change the result. The 66.4% and 50.3% are orders of magnitude, not a scoreboard.

The break-even example is hypothetical. It takes the 9x ratio measured on computer use and applies it to terminal tasks. It's there to show the reasoning, not as a final number. Run it with your own data.

Pricing above 272k tokens changes everything. The 1.05M context is real, but using all of it costs a lot more than the headline table suggests.

Gradual rollout. In ChatGPT Work and Codex, access may take a while to reach every account.

Quick FAQ

GPT-6.1 Terra vs Opus 5.5: which is better for coding? Going by the numbers each lab reported, Opus 5.5: 66.4% vs 50.3% on Terminal-Bench 4.0. And OpenAI itself recommends GPT-6.1 Sol or GPT-6 Astra, not Terra, for more complex code. Terra shines at computer use and volume.

How much does GPT-6.1 Terra cost? US$ 1 per million input tokens, US$ 0.05 for cache and US$ 5 for output. Batch and Flex get 50% off. Requests above 272k input tokens pay 2x on input and 1.5x on output.

GPT-6.1 Terra vs Sol: what's the difference? Terra costs half (US$ 1/US$ 5 vs US$ 2/US$ 10) and is more than 3x faster, according to OpenAI. Sol is still the pick for hard code and heavy reasoning. On Agents' Last Exam, Terra even beat Sol, but that's a computer use benchmark. To understand the logic behind the tiers, check out our guide to Sol, Terra and Luna from the 5.6 generation.

Is there an independent benchmark of GPT-6.1 Terra yet? As of October 31, 2026, no. Everything out there is OpenAI's numbers. Before migrating an agent in production, run your own eval.

Conclusion

GPT-6.1 Terra is OpenAI's first mid tier that seems to have fixed its predecessor's problem. In computer use, even after discounting lab numbers, the cost-per-task math works out with room to spare.

In coding agents, it doesn't. Not because Terra is bad, but because failures in code are expensive, and a model that scores 16 points lower needs to be a lot more than 9x cheaper to make up for the dev time spent reviewing.

The next round of this fight will be decided by the first independent benchmark. When it comes out, we'll redo the math here. Until then, if you're picking a top-tier model for long-running agents, it's worth seeing how caching changes the math of GPT-6 Astra vs Fable 5.1.