Author(s): Arjun Patel

Originally published on Towards AI.

“Why Would You Pick Terra Over Sol?” A Routing Guide for GPT-6.1 Terra vs Sol

Open the model picker after GPT-6.1 Terra and the question is already in the replies: “Why would you pick Terra over Sol?” On Hacker News it looks like a “weird middle child”; on Reddit someone asks whether Terra even makes sense if Sol wins most benches at almost the same cost.

The rest of this guide answers that question in order: what Terra is actually built for, when half-price tokens still cost more, where it breaks, then one routing table and a checklist before anyone changes the default.

Why Would You Pick Terra Over Sol?

Start with Terra at medium effort for clearly specified screen work, visual checks, or writing from supplied material. Keep Sol at medium for complex coding. Move a task to Terra when it meets the same requirements with less total cost or waiting, including corrections and review.

The benchmark disagreement explains why this GPT-6.1 Terra vs Sol decision needs a task attached to it. Lucky_Creme_5208’s claim that Sol wins every benchmark except Agents’ Last Exam is too broad: OpenAI’s Terminal-Bench-Science 0.1 results give Terra at max 58.3% at $4.15, against Sol at max at 57.0% and $5.47. That directly contradicts the comment’s ‘except ALE’ summary. It concerns scientific research tasks performed through code; it doesn’t settle a difficult application repair.Why Would You Pick Terra Over Sol?

The skepticism is specific, not vague. One Reddit summary of the launch numbers put it bluntly: “In every benchmark other than Agents’ Last Exam, GPT 6.1 Sol outperforms 6.1 Terra at almost same costs.”

That reading collides with OpenAI’s own launch claims, which put Terra on par with GPT-6 Astra on Agents’ Last Exam at medium effort and ahead of Sol on Terminal-Bench-Science 0.1 at lower cost (as summarized by DataCamp). Both statements can be true at once. They are measuring different tasks, at different effort settings, with different cost accounting. That is exactly why a single leaderboard cannot settle the routing decision.

Short answer: For computer use, visual tasks, and technical communication, Terra is worth comparing with Sol on the work you actually need done. Choose it when it meets the same requirements with less total cost or waiting time, including retries and review. Keep Sol where Terra needs enough correction to erase that advantage.

A single leaderboard cannot tell a routing layer where every job belongs. If your existing Sol setup already finishes correctly, compare one relevant task before changing its default.

If Terra isn’t simply a cheaper Sol, what work is it actually meant to carry?

What Terra Is Actually Built For

OpenAI’s model-selection guidance points to defined computer-use tasks, writing from existing material, and scoped code fixes. The common thread is a supplied input and a result someone can check.

For computer use, that might mean filling a web form from documents already on hand. Faster actions can reduce the wait across a long sequence, but the check is the saved record. A wrong date or duplicated entry makes the task a failure even when every click succeeded.

For vision, it might mean checking screenshot fields against a record or reading a technical drawing. Inspect the detail that determines the next action: a unit, a decimal, or a label attached to the right part. A fluent description can still miss the one detail the job required.

For technical communication, it might mean turning supplied material into setup notes or an explanation for a particular reader. Check whether facts, exceptions, and required actions survived the rewrite. Shorter text helps when it preserves what the reader needs.

Ted Sanders of OpenAI describes Terra as “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” (as quoted by Simon Willison). That’s an employee’s assessment, with a clear tradeoff: speed on these jobs is a reason to compare Terra, while general-purpose expectations can lead elsewhere.

The disappointment described by @studio_yebisu and the computer-use emphasis in /u/industrial_illusions’s reply fit that distinction. Neither establishes that Terra cannot compete on any other task.

The official Agents’ Last Exam v1 results make the computer-use case concrete. At medium effort, Terra scores 57.6% at an estimated $0.29, versus Sol’s 53.8% at $1.31. These are vendor-reported professional computer-use results. Your forms, documents, and failure costs will differ.

Fitting the use case is only the first step. If tokens cost half as much, does finishing the task cost half as much too?

When Half-Price Tokens Still Cost More

Is Terra Still Cheaper After Retries?

Count every attempt needed to reach the same acceptance bar. Standard short-context API rates are $1 input / $5 output per million tokens for Terra, versus $2 / $10 for Sol. The saving applies to the same billed token quantities.

Take a request with 10,000 uncached input tokens and 2,000 billed output tokens:

Two identical Terra attempts tie one successful Sol attempt. A third takes Terra to $0.06, more than that Sol run’s $0.04. The example holds token quantities constant and excludes caching, tools, and other fees. Actual correction prompts and reasoning can change the quantities.

For a batch, use total API spend across all attempts ÷ accepted completed tasks. If nothing passed, there’s no usable unit cost to report. Keep human review and repair time in a separate column: their cost varies, but the time still affects whether a route is worth keeping.

That gives the retry concern raised by /u/cn-dev a number you can inspect. A lower rate saves money only while extra attempts stay below the amount that consumes the saving.

Codex subscription allowance needs its own record. Half-price API tokens don’t imply that a task consumes half the percentage of a plan limit.

Does a Higher Reasoning Setting Change the Cost?

Yes. A higher setting can generate more reasoning tokens as well as visible output, and OpenAI bills reasoning tokens as output. A short final answer can therefore carry a large output-token bill.

Halve the output rate and double the billed output tokens, and the output-cost advantage disappears. Increase the quantity further and that component costs more. The total request also includes input and any other fees, so doubling output alone doesn’t necessarily double the whole bill.

This is the mechanism behind comparing a more expensive Terra setting with a lower Sol setting. /u/lordpuddingcup argues that Terra at a very high setting can lose its cost advantage over Sol medium. That’s a reported configuration comparison, not proof that Terra costs more on every job.

Use the actual setting names when recording your own comparison. Terra’s model page lists none, low, medium, high, xhigh, and max; Sol lists low, medium, high, xhigh, and max. The commenter's vhigh isn't Terra's documented API setting name.

Start at the same supported effort and inputs. Raise effort for a specific failure, then compare the configurations that actually pass. Record billed output, its reasoning-token breakdown, retries, and time to a usable result. TB-Science shows that Terra max can retain an advantage; the terminal results below show why that doesn’t transfer to every coding task.

Where Terra Breaks (Keep Sol or Opus)

Keep the working model when Terra repeatedly misses what makes the result acceptable. For difficult coding, that can mean long dependencies across files, an uncertain root cause, or a repair that must preserve behavior elsewhere.

OpenAI reports 50.3% on Terminal-Bench 4.0 at Terra’s maximum effort. Its chart puts Claude Sonnet 5.5 near 70%, at a substantially higher plotted cost. An HN comment calls that model Opus 5.5; the official chart labels it Sonnet 5.5. The distinction matters when someone uses the comparison to choose a model.

The cost objection is more useful than the headline gap alone. Starlevel004’s HN comment observes that Terra XHigh costs more than Sol Low while scoring worse on that chart. It challenges a particular terminal configuration. Combined with OpenAI’s recommendation to retain Sol or Astra for the most complex coding, it gives a reason to keep those jobs on a working route. It doesn’t overturn the ALE or TB-Science results, which measure different work.

The Reddit discussion also contains a concrete failure report from /u/ayudha90. The assignment was a 2D pixelated construction-themed project-management interface. The poster preferred the visual variety from Sol medium and Opus 5.5 medium to Terra max’s simpler result.

The poster reported spending 33% of a five-hour allowance on Terra max, after 6% on an earlier high-effort attempt, versus 24% for Sol medium. Those are one user’s allowance figures, not measured API bills. Percentages from different providers’ plan limits aren’t interchangeable money.

The failure relevant to routing was unmet visual variety after increasing effort. For a similar brief, keep the configuration that already meets it if Terra needs repeated direction and still falls short. This report doesn’t establish a failure rate for creative work or a general Opus-over-Sol ranking.

A contained bug fix belongs in a separate comparison from that design assignment or a complex terminal task. OpenAI specifically includes scoped fixes among Terra’s uses. Route the particular repair or project, including its completion requirements.

OpenAI’s Terminal-Bench 4.0 Chart

The official coding benchmark chart supplies context for the forum objection without determining all coding routes.

OpenAI’s vendor-reported Terminal-Bench 4.0 chart from its Terra announcement. Screenshot captured with browser tools, October 27, 2026.

The Routing Table: Task → Model → Effort

The evidence above gives a starting configuration and a reason to change it:

Medium is the starting effort here. Keep the setting that passes your task at the best total cost; the table doesn’t prescribe a new Opus setting.

Checklist Before You Change the Default

Run three tasks from actual work: a repeatable screen or document job, one with easy-to-miss details, and a harder job currently handled well by Sol. Supply the same material and define “passed” before running either configuration.

• Completion: count results that meet the requirements. Producing a file or executing every step doesn’t establish success.
• Retries: include each correction and rerun, even when its output was discarded.
• Time: measure time to an acceptable result, plus the review and repair needed to get there.
• Cost: include failed runs and retries in API spend. Record subscription allowance separately.

Three tasks answer a local question: does this routing hold for this workload? Save the inputs and acceptance requirements so the decision can be checked again when the model or workflow changes.

So, why pick Terra over Sol? For the jobs it finishes to the same standard with less total spend or waiting. Keep Sol, or an existing Opus configuration, where corrections consume that advantage. A routing layer earns its complexity when it can make that distinction: Terra gets the tasks where its speed and price survive completion, and proven configurations keep the rest.

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI