GPT-6.1 Terra vs GPT-6.1 Sol: Half the Price, Not Always Cheaper

GPT-6.1 Terra (gpt-6.1-terra), released by OpenAI on October 26, 2026, costs exactly half of GPT-6.1 Sol (gpt-6.1-sol) per token on every tier where both are sold: $1 input and $5 output per million tokens against Sol's $2 and $10 on the OpenAI API pricing page, and half of Sol's Codex credit rate as well. That makes Terra cheaper per finished task only while you run it at low or medium reasoning effort. If a job needs Terra at max effort to reach the quality you want, Sol at medium reaches the same Artificial Analysis Intelligence Index score (48) for $0.21 per task instead of $0.40, and in 149 seconds instead of 384, according to the Artificial Analysis GPT-6.1 Terra vs GPT-6.1 Sol comparison.

So start with Terra at low or medium for routine coding fixes, reading invoices and charts, form filling, computer use, and writing, and keep Sol at medium or higher for hard multi-step coding. On October 27, 2026, both models passed three small Codex CLI tasks on every run; at medium effort, Terra finished the four paired runs in 121.5 seconds and 2.30 Codex credits, Sol in 246.7 seconds and 5.56 credits. Those tasks were too easy to separate the two on quality. Harder benchmarks do: on Terminal-Bench 4.0 at medium effort, Artificial Analysis measured 32.3% for Terra and 48.0% for Sol.

To try it in Codex, run codex -m gpt-6.1-terra on Codex CLI 0.159.0 or later, and judge it by cost per accepted task on your own work rather than by the per-token price. Four limits make the choice for you: Terra has no Ultrafast tier, Sol has no none effort, neither model is in ChatGPT Chat (both are in Work and Codex), and Terra doesn't support UAE inference residency.

Which to use: GPT-6.1 Terra for routine and visual work, Sol for hard coding

Pick by how hard the task is and how much reasoning effort it needs to pass. Terra wins when low or medium effort is enough, because it is then both cheaper and faster per task than any Sol setting with a similar score. Sol wins when the work is hard enough that Terra would need xhigh or max to keep up, because at that point Sol medium gives the same result for less money and less waiting. OpenAI's own split is the same: the Codex models page calls Terra "a fast, efficient choice for writing, visual understanding, and computer use," and the GPT-6.1 Terra launch post says GPT-6.1 Sol and GPT-6 Astra "remain the better choice" for the most complex coding tasks.

"GPT Terra" can mean two models. GPT-6.1 Terra is the first new Terra since GPT-5.6 Terra, which is still on OpenAI's price list at $2 input and $12 output per million tokens, so the new model is cheaper than the old one as well. Use the full model ID in configs and tests. GPT-6.1 Terra also has the later knowledge cutoff of the pair: June 1, 2026, against April 30, 2026 for Sol, per the GPT-6.1 Terra model page and the GPT-6.1 Sol model page.

GPT-6.1 Terra vs Sol pricing: exactly half on every tier, no Terra Ultrafast

Every Terra price is half the matching Sol price, on short and long context, Batch, Fast, cache writes, and Codex credits. The only tier where the comparison breaks is Ultrafast, which OpenAI offers for Sol and not for Terra. The rates below are per million tokens, as of October 27, 2026, from the OpenAI API pricing page and the Codex credit table on the ChatGPT and Codex pricing doc.

The long-context rate applies to the whole request once its input passes 272K tokens, and both models have the same 1.05M-token context window and 128K maximum output. Regional processing endpoints add 10% for both. Codex credits have no separate cache-write charge, so the API's cache-write columns don't apply inside Codex. In Codex, Ultrafast is limited to the Pro $500 plan and eligible Enterprise and Edu plans, so if you rely on it for Sol, Terra can't replace it there. For Sol's own access rules and what changes when you move from GPT-6 Sol, see GPT-6.1 Sol: Pricing, Access, and What Breaks When You Switch; for how 30-minute and 12-hour cache writes add up on a long prompt, the worked examples in GPT-6 Astra API Pricing: $10/$50 per 1M Tokens, Caching Costs carry over at these lower rates.

Is Terra cheaper per task? At low and medium effort, yes; at max, no

Terra's half-price tokens only save money if it doesn't spend twice as many of them. At low and medium effort it doesn't, so it stays cheaper per task than Sol at a similar score. At max effort it does, and Sol becomes the cheaper way to reach the same score. The pairs below come from the Artificial Analysis comparison, which runs both models through the API at every effort level and reports Intelligence Index v4.3.2, the cost of one Index task, and the time per task, as of October 27, 2026.

The ratios are plain division of those figures: $0.10 ÷ $0.13 = 0.77 and 63 ÷ 75 = 0.84 for the medium-versus-low pair; $0.40 ÷ $0.21 = 1.9 and 384 ÷ 149 = 2.6 for the max-versus-medium pair. At the top, Sol max scores 52 for $0.72 per task, four points above anything Terra reaches. Terra's none setting (Artificial Analysis labels it non-reasoning) scored 33 at $0.11 and 52 seconds per task, so on this benchmark it was neither cheaper nor faster than Terra low. Treat that as a reason to test low before assuming none saves money.

Two cautions keep this from being a universal rule. Terra at xhigh does not score below Sol at low on this table; it scores higher and simply costs more, so the clean case for Sol is the equal-score one at the bottom. And the Index is a composite of many tasks, so your own workload can rank the two differently. Artificial Analysis summarized its first results on X by calling Terra's low and medium settings Pareto-optimal, which matches the table: those are the settings where nothing else gives more score per dollar.

Is GPT-6.1 Terra really 3× faster than Sol?

Only for whole tasks in OpenAI's own setup. The launch post's "over three times faster than both GPT-6 Astra and GPT-6.1 Sol" sits in its section on Agents' Last Exam, OpenAI's computer-use evaluation, so it describes how quickly the model finishes those tasks, not how fast it streams tokens. Raw output speed is a smaller gap: Artificial Analysis measured Terra at 91 tokens per second at every effort and Sol at 54–73, about 1.2–1.7× in Terra's favor. The rest of the per-task gap comes from Terra producing fewer tokens to finish the same task.

Measured per task, the gap depends on effort. In the Artificial Analysis runs, Terra low took 29 seconds per task against 75 for Sol low (2.6×), Terra medium 63 against 149 for Sol medium (2.4×), and Terra max 384 against 527 for Sol max (1.4×). In the Codex CLI runs below, Terra finished in about half of Sol's wall time at matching effort. The largest gap reported so far is a single anecdote: an OpenAI Codex team member posting as @victornunez on X shared a form-filling computer-use run in Fast mode in which Terra took 53.5 seconds and Sol 3 minutes 21.7 seconds. If Sol feels slow for reasons beyond the model choice, GPT-6.1 Sol Slow in Codex or API? Causes and Tested Speed Fixes covers effort and Fast settings.

Codex CLI test on October 27, 2026: both passed, Terra took half the time

Three small tasks were run on both models in Codex CLI on October 27, 2026, and both models passed every run, so the test shows time and usage rather than a quality gap. The environment was codex-cli 0.164.0-alpha.11.1 bundled with the ChatGPT desktop app on macOS, signed in with one ChatGPT subscription account, at Standard speed, between 03:55 and 04:08 UTC. Each run started from a fresh copy of the task folder with codex exec --ephemeral --ignore-user-config --skip-git-repo-check -s workspace-write -m <model> -c model_reasoning_effort=<effort> -c service_tier="default" --json, and the models were interleaved. The billing task asked for a buggy billing.py to be fixed against a seven-rule spec, checked by 36 hidden tests. The image task gave the model two PNGs, a 12-line invoice containing one deliberately wrong line total and a bar chart with 12 unlabeled bars, and graded 40 numbers, 12 chart values, and whether the wrong line was flagged. The semver task asked for a satisfies() function written from a long range spec including npm's prerelease rule, checked by 36 hidden tests.

Credits here are computed, not billed: each run's token usage from Codex's turn.completed event multiplied by the published credit rates (25 / 1.25 / 125 for Terra, 50 / 2.5 / 250 for Sol). On a subscription these runs drew on included usage. Adding the four medium pairs gives Terra 121.5 seconds and 2.30 credits against Sol's 246.7 seconds (summed from unrounded run times; the rounded table values add to 246.6) and 5.56 credits, so Sol took 2.0× the time and 2.4× the credits. Run by run at the same effort, Sol used 1.7–3.0× Terra's credits and 1.5–2.3× its wall time. The token rates explain 2× of the credit gap. The rest is Sol writing more output and reasoning tokens, and in the image task taking more steps: Sol at medium ran six commands and read 196K input tokens, most of them cached, while Terra at medium ran two. That step count varies from run to run, which is why Sol high finished the image task faster than Sol medium.

Both models chose to crop and zoom the images with Python's PIL before answering, which the prompt allowed. Both also misread the same two part numbers, where a lowercase l, a capital I, and the digit 1 look nearly identical in the invoice font; those two were left out of the score. The limits are real: one account, one Mac, mostly single runs, Standard speed only, no Fast or Ultrafast, and no direct API calls, so Codex's own agent overhead is inside every number. These tasks were small enough that both models' test-and-fix loops got them right. They tell you that Terra finishes routine work faster and on less usage; they don't tell you it codes as well as Sol on hard problems.

Is Terra worse at coding? On hard tasks at the same effort, yes

At the same effort, Terra solves far fewer hard coding tasks than Sol, and only closes the gap at max. On Terminal-Bench 4.0, where an agent fixes real problems from the command line, Artificial Analysis measured Terra at 15.2% on low, 32.3% on medium, and 55.6% on max, against Sol's 30.8%, 48.0%, and 56.1%. OpenAI's launch post reports 50.3% for Terra at max effort on the same benchmark in its own setup, more than twice GPT-5.6 Terra's 21.5%, and still says Sol and GPT-6 Astra remain the better choice for the most complex coding.

That gives a usable rule for coding agents. If your tasks are like the Codex test above, with clear specs and tests the agent can run, Terra at low or medium will usually pass faster and on less usage. If they look like Terminal-Bench, with multi-step debugging and no obvious path, Sol medium is the better start: of the published Terra settings, only max beats Sol medium's score, and max is the setting where Terra costs more per Index task than Sol medium and takes longer. Discussion in the r/codex launch thread, which passed 370 comments within a day, ran the same way: Terra can look excellent on specific workflows, while Sol stays better for harder coding. If Sol at high still fails your hardest jobs, GPT-6.1 Sol vs GPT-6 Astra vs GPT-6 Sol: When Astra Is Worth It covers that step up.

Vision, forms, and computer use: where Terra is good enough

For reading images and working through apps, Terra matched Sol in the Codex test and comes close in OpenAI's evaluations, at a much lower cost. In the October 27 invoice-and-chart task, every Terra run, including the one with effort set to none, got all 40 invoice numbers and all 12 chart values right and flagged the planted error, just as Sol did, in 29–38 seconds against Sol's 55–79. That task used clean synthetic images, so treat it as a floor rather than proof on scanned receipts or crowded screenshots.

OpenAI's launch post says Terra scores close to GPT-6 Astra and GPT-6.1 Sol on the MMMU-Pro visual reasoning benchmark at much lower cost, beats GPT-5.6 Terra's best OSWorld 2.1 result already at medium effort, and cuts its error rate on an internal set of hallucination-prone prompts to 16.7% at low effort and 4.3% at max. Those are OpenAI's own evaluations, and the Sol values appear only in chart images. Readings of those charts posted on X put the two within about a point on Agents' Last Exam (about 60 vs 59), MMMU-Pro (about 85.5 vs 86.3), and OSWorld 2.1 (about 78 vs 79), and about six points apart on Terminal-Bench 4.0. The one place Sol stays clearly ahead outside coding is recall: on Artificial Analysis's Omniscience knowledge and hallucination test, Sol scored 38–42 across efforts and Terra 4–30. If a form or document task needs facts that aren't on the page, check Terra's answers against a source.

Where you can use GPT-6.1 Terra and Sol: Work and Codex, API, Copilot

Both models are in ChatGPT Work and Codex but not in ChatGPT Chat, both are in the OpenAI API, and Terra is also rolling out in GitHub Copilot. The differences that can block a switch are in the table, as of October 27, 2026, from the ChatGPT and Codex pricing doc and the two model pages.

OpenAI's launch post lists Plus, Pro, Enterprise, and Edu for Terra and leaves out Business. The Codex pricing doc names Business too, and it is the more specific page, so Business users should look for Terra in the picker before assuming it's missing; pickers also vary by workspace and rollout. In GitHub Copilot, the GitHub changelog entry for GPT-6.1 Terra lists Copilot Pro, Pro+, Max, Business, and Enterprise, rolling out gradually and billed at provider list prices under usage-based billing. Third-party OpenAI-compatible gateways can lag behind: on October 27, 2026, laozhang.ai's /v1/models list included gpt-6.1-sol but not gpt-6.1-terra, so check a gateway's model list before pointing a pipeline at Terra.

Disclosure: laozhang.ai is our own service. Its prices are platform pricing, not an independent comparison.

Codex usage per 5 hours: Terra 35–285 messages, Sol 15–160

On Plus and Standard Business, OpenAI's estimate for one five-hour window is 35–285 local messages with GPT-6.1 Terra against 15–160 with GPT-6.1 Sol, so Terra roughly doubles what you can do before hitting the window. The figures are from the usage table in the ChatGPT and Codex pricing doc as of October 27, 2026, which calls them estimates rather than fixed limits: a big task uses more than a small one, cloud tasks can use more, and weekly limits may also apply. Pro plans currently have no five-hour limit. For comparison, the same table gives GPT-6 Astra 5–45 and GPT-6 Luna 350–3,000.

Keep three meters apart when you compare. Plan usage is the message range above. Codex credits apply once plan limits run out, or for flexible-pricing workspaces, at the credit rates in the pricing table, and OpenAI notes that credit prices alone don't determine included usage. API dollars are a separate bill for API-key traffic. If you hit the weekly cap rather than the five-hour one, Codex Weekly Limit Reset: Find Your Time or Reset Now explains the timing, and a "selected model is at capacity" message is a different problem, covered in Codex “Selected Model Is at Capacity”: Not Your Limit, What to Do.

How to switch Codex or the API to GPT-6.1 Terra

Switching takes a model name and, usually, an effort setting; the order below avoids the common failure of an outdated CLI that doesn't know the model.

1. Check your CLI with codex --version. Terra needs Codex CLI 0.159.0 or later, according to the Codex models page.
2. Start a session on Terra with codex -m gpt-6.1-terra, or add -c model_reasoning_effort=low to set the effort at launch. The same -m flag works with codex exec.
3. Inside a running CLI session, type /model to switch between gpt-6.1-terra and gpt-6.1-sol or change the effort without restarting.
4. In the ChatGPT desktop app or ChatGPT Work on the web, open Advanced in the Power control and pick GPT-6.1 Terra.
5. In the API, set model to gpt-6.1-terra and reasoning.effort to the level you tested; use the Responses API if the request calls tools. If you move a workload that runs at none, remember that Sol's lowest setting is low, so moving back to Sol adds reasoning time.

Test Terra against Sol on your own tasks before changing the default

The only number that settles the choice for your work is cost per accepted task: total spend for a batch divided by the number of results you'd keep without fixing. A one-hour test with tasks you already know the answers to is enough to see which side of the effort line you're on.

1. Collect 10–20 recent tasks with a clear pass check, such as tests, a diff you'd merge, or extracted fields you can compare.
2. Run each on Terra low, Terra medium, and Sol medium, alternating the models so a busy period doesn't favor one.
3. Record for each run whether you'd accept it, the wall time, and the token usage (Codex prints it; the API returns it in usage).
4. Convert usage to dollars or credits with the rates in the pricing table, then divide each setting's total by its accepted count.
5. Keep Terra as the default at the lowest effort whose acceptance rate matches Sol medium. If Terra needs high or above to match, compare that setting's cost per accepted task with Sol medium before switching, because that's where the equal-score result above usually flips.

For the four medium pairs in the October 27 Codex test, all eight runs were accepted, so cost per accepted task is just each model's average: about 0.58 credits for Terra and 1.39 for Sol. Your tasks will be harder, and the gap will narrow as Terra starts failing some of them. Running this check on your own work tells you how far it narrows.