GPT-6.1 Terra Pro vs GPT-6.1 Sol: Pick by the Work, Not the Price Card

GPT-6.1 Terra Pro versus GPT-6.1 Sol is the matchup people search for, but only one side of that name is real: OpenAI’s model is GPT-6.1 Terra, and “Pro” is a ChatGPT plan label, not a variant. The comparison that matters is GPT-6.1 Terra against GPT-6.1 Sol, two models from the same generation with the same 1.05-million-token context window, the same 128,000-token output ceiling and a two-to-one price gap. The useful question is not which one is better. It is which one is better at the work you are about to hand it.

That framing changes the answer. On the independent index, Sol is four points ahead. On price, Terra is half. On speed, Terra is more than three times faster by OpenAI’s own measurement. None of those three facts decides the matchup by itself, because each one maps to a different part of a workload: quality, cost and latency. The model that wins depends on which of those your task is actually short of.

The short answer

If the work is a browser or desktop agent clicking through applications, a form-filling pipeline, an invoice queue, a technical drawing that has to become a model, or a document that has to be written clearly from supplied material, start with GPT-6.1 Terra. If the work is a long refactor, a multi-file feature, a hard debugging session, a dense professional document or a research task that runs for hours, start with GPT-6.1 Sol. If you need the fastest paid tier OpenAI sells, Sol is the only one of the two with an Ultrafast option.

That is the shape of it. The rest of this piece is the evidence, the places the shape breaks, and the settings that can flip the answer.

Two models, two jobs

GPT-6.1 Terra’s brief is the workday: visual reasoning, computer control, and writing that reads like a person wrote it from material someone supplied. OpenAI’s announcement names drafting proposals, interpreting technical drawings, filling out forms and editing video. GPT-6.1 Sol’s brief is the harder, longer work: near-Astra coding and professional documents, with OpenAI recommending Sol or Astra for the most complex coding tasks even in the Terra launch post.

Ted Sanders of OpenAI, quoted across launch-day coverage, put the trade more bluntly: Terra is 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. That is a vendor description rather than an independent finding, and it is a useful one because it names the trade instead of hiding it.

Both models share the same skeleton: 1.05 million tokens of context, 922,000 maximum input, 128,000 maximum output, text and image input, Chat Completions and Responses endpoints, and no fine-tuning. The differences are the knowledge cutoff (Terra June 1, 2026; Sol April 30, 2026), the reasoning floor (Terra accepts none; Sol starts at low), the speed tier (Sol has Ultrafast; Terra does not) and the price card.

Where the benchmarks separate

Artificial Analysis is the cleanest independent read: 48 for Terra at max effort against 52 for Sol, ranks 25 and 13 of 221, and $0.40 against $0.72 per index task. Four index points is a real gap, but it is the kind of gap that a task-specific evaluation can erase in one direction or the other.

• Overall index — Terra 48 vs Sol 52 (Artificial Analysis).

• Coding Agent Index v2.0 — Terra 48 vs Sol 54, with GPT-6 Luna at 31 (Artificial Analysis).

• Terminal-Bench 4.0 — Terra 50.3% at max effort; OpenAI published no Sol figure alongside the Terra launch (vendor-reported).

• Terminal-Bench-Science 0.1 — OpenAI says Terra at max effort surpasses Sol at lower cost and comes within five points of Claude Opus 5.5 at under one-fifth the estimated cost (vendor-reported, and the most surprising claim in the launch).

• Plotly data-analysis exam — Terra 40/43, Sol 43/43, Luna 38/43, at $1.31 against $2.61 for the exam; Terra was the fastest model to reach 40 or more, at about 15 seconds per question (third-party evaluation).

• OSWorld 2.1 — OpenAI says Terra at medium effort beats GPT-5.6 Terra’s best score at a fraction of the cost, but published no head-to-head Sol number, so the computer-use claim that matters most for Terra’s positioning is the one with the least direct evidence.

Read that list as a map of where the four points live. Sol’s advantage is concentrated in coding and long-horizon reasoning. Terra’s advantage is speed, price and the fresher cutoff. On the one benchmark OpenAI chose to publish against Sol directly, Terminal-Bench-Science 0.1, Terra wins at lower cost, which is either a genuine upset or a benchmark-selection effect. Nobody outside OpenAI has reproduced it.

The effort dial decides more than the model does

Both models expose reasoning effort, and the setting can cost more than the model choice. Terra’s floor is none, which makes it unusually cheap for extraction and classification; Sol’s floor is low, so a Sol call always pays for some reasoning. At the top end, Terra at xhigh can consume more tokens and cost more than Sol at low while scoring worse on the same task, an observation Hacker News commenters made within hours of launch. We have not measured it ourselves, and it is arithmetically plausible: effort changes token count multiplicatively, while the price gap is only 2×.

The practical rule is to pin effort by evaluation, not by habit. Run fifty real tasks through both models at two effort levels, set a quality bar, and choose the cheapest pair that clears it. Comparing Terra and Sol at the same nominal effort is the most common mistake in this matchup and the one most likely to produce a wrong answer.

What a finished task costs

• Input — Terra $1.00 per million tokens vs Sol $2.00.

• Cached input — $0.05 vs $0.10.

• Output — $5.00 vs $10.00.

• Cache writes — $1.25 at 30-minute retention or $2.50 at 12-hour retention for Terra; $2.50 for Sol.

• Long prompts — above 272,000 input tokens both charge twice the input and cache rate and 1.5 times the output rate for the whole request.

• Measured cost per index task — $0.40 for Terra vs $0.72 for Sol, a 44% saving rather than the 50% the price card implies, because Terra can burn more tokens at max effort.

A worked example with clean assumptions: 2,000 input tokens and 500 output tokens per document, no cache. Terra costs $0.002 for input plus $0.0025 for output, or $0.0045 per document. Sol costs $0.009. A million documents is $4,500 against $9,000. If half the input is cached, Terra’s input cost halves again; Sol’s falls by the same proportion, so the ratio holds. The gap widens only where Terra’s none setting is usable, and narrows where Sol finishes the task in fewer tokens.

Access is part of the comparison

Terra is available in the API and in ChatGPT Work and Codex on Plus, Pro, Enterprise and Edu plans; OpenAI’s announcement does not list the main Chat picker. Sol is available in the API and in ChatGPT, and it is the only one of the two with an Ultrafast mode; both offer Fast at twice the standard price. On a Pro 500 plan, Ultrafast consumes included usage at eight times the standard rate and purchased credits at six times, so “faster” is a billing decision as much as a latency one.

On the routing side the asymmetry is simple. GPT-6.1 Sol is in the OrcaRouter catalogue at list price, $2 input and $10 output, with no markup, so a vendor price change passes through on the same terms. GPT-6.1 Terra is not in the catalogue yet as of October 27, so Terra calls have to go to OpenAI’s own API; that is a fact about today’s catalogue, not a permanent position. Automatic failover across the models we do carry is the reason to keep a second arm configured even when one model is clearly cheaper.

A selection rule you can run this week

• Classify the task by what it needs: screen control and document production point at Terra; code, long reasoning and dense research point at Sol.

• Fix a quality bar on your own data before you look at the price card. Four index points is not a quality bar; your evaluation is.

• Test at two effort levels, not one. Terra at none against Sol at low is a different comparison from Terra at max against Sol at max.

• Price the finished task, including retries and tool calls. Per-token arithmetic undercounts the model that needs more turns.

• Keep the loser as a failover arm. The cheapest model that is rate-limited is not cheap.

If you route through OrcaRouter, that last step is configuration rather than code: one key, a routing rule per task class, and failover when a provider degrades. The two models can sit behind the same endpoint once Terra is carried; today only Sol is.

What would change the answer

Three things. An independent coding evaluation that puts Terra close to Sol would collapse the main reason to pay double. A published OSWorld 2.1 head-to-head would settle the computer-use claim OpenAI left implicit. And a Terra listing on the routers would make the failover story real rather than aspirational. Until then, the defensible default is Terra for volume and screen work, Sol for code and long reasoning, and an evaluation in between rather than a slogan.