Appearance
What Is GPT-6.1 Terra? OpenAI's Computer-Use Model Explained
GPT-6.1 Terra is OpenAI's mid-tier model for visual reasoning and large-scale computer use. It replaced GPT-5.6 Terra on October 26, 2026, at half the API price — $1 per million input tokens and $5 per million output tokens — while landing within a few points of models that cost up to ten times more.
The interesting part of this release isn't a new intelligence record. Terra trails OpenAI's own GPT-6.1 Sol on most reasoning benchmarks and sits well below Claude Opus 5.5 on third-party indices. What OpenAI shipped is a cheaper way to run agents that look at a screen and click things — the unglamorous work that eats most of an automation budget.
That makes Terra a model you evaluate with a spreadsheet rather than a leaderboard. Below: where it fits in the lineup, what computer use means mechanically, the published numbers with sources, why the price matters more than the score, and who should migrate. Nolvia runs Terra next to Sol, Astra, and Opus 5.5 in one browser tab if you'd rather test than read.
Table of Contents
- Where Terra Sits in the GPT-6.1 Family
- What Computer Use Actually Means
- Benchmarks and Cost per Task
- Why the New Price Point Changes the Math
- What Changes in Practice for Agent Builders
- Where Terra Still Falls Short
- Who Should Switch Now, and Who Should Wait
- Running Terra Alongside the Rest of the Field
- FAQs
- Related Articles
Where Terra Sits in the GPT-6.1 Family
OpenAI's lineup is four tiers deep: Luna, Terra, Sol, and Astra. Astra is the GPT-6 flagship that arrived in early September 2026 at $10/$50 per million tokens. Sol and Luna followed in late September, with Sol moving up to the GPT-6.1 generation on September 29. Terra was the last tier still on GPT-5.6.
Terra is the middle tier, and the label is accurate rather than marketing fluff:
- Luna is the cheap, high-volume tier for narrow, well-defined tasks.
- Terra is the workhorse — visual reasoning, computer use, drafting, routine coding.
- Sol is the stronger reasoning and coding tier at $2/$10 per million tokens.
- Astra is the frontier tier, reserved for the hardest research and engineering work.
Two things get confused constantly. Terra isn't a cut-down Sol — it's a different model with a different emphasis, and OpenAI still points people to Sol or Astra for demanding coding and research. The naming also marks a tier, not a version: GPT-6.1 Terra is newer than GPT-6 Sol, and its scores don't line up neatly against any single sibling.
What Computer Use Actually Means
A chat model takes text and returns text. You read the answer and act on it. A computer-use model takes a screen state, returns an action, observes the result, and repeats — screenshot in, click and keystroke out, verification loop in between.
The mechanics change the failure mode. In chat, a bad answer wastes a paragraph. In computer use, a misread button cascades: the agent clicks the wrong row, the invoice lands under the wrong vendor, and every later step builds on that error.
OpenAI's examples for Terra are deliberately mundane — keying invoices into accounting software, filling browser forms, matching product photos to catalog entries, turning technical drawings into 3D models. None of it needs frontier reasoning; all of it needs a model that sees accurately, acts precisely, and knows when it has failed.
Two benchmarks cover this ground: Agents' Last Exam for end-to-end professional software tasks, and OSWorld 2.1 for multi-step desktop workflows. Both reward a model that recovers from a pop-up or a shifted layout without human rescue — exactly where cheap models break.
Benchmarks and Cost per Task
Benchmark scores below are OpenAI's published figures. Intelligence index and cost-per-task figures come from Artificial Analysis, an independent evaluator. Blank cells are values we could not confirm from a primary or reputable secondary source.
| Metric | GPT-6.1 Terra | GPT-5.6 Terra | GPT-6.1 Sol | Claude Opus 5.5 |
|---|---|---|---|---|
| Agents' Last Exam | 60.0% | 50.7% | 58.6% | 63.2% |
| OSWorld 2.1 (offline) | 74.2% | 57.1% | 78.0% | — |
| MMMU-Pro (visual reasoning) | 85.5% | 81.7% | 86.3% | — |
| Terminal-Bench 4.0 (max effort) | 50.3% | 21.5% | 55.9% | — |
| Factual error rate (max effort) | 4.3% | 22.3% | — | — |
| API input / output per 1M tokens | $1 / $5 | $2 / $12 | $2 / $10 | $4 / $20 |
| AA intelligence index | 48 | 42 | 52 | 58 |
| AA cost per task | $0.40 | $1.40 | — | — |
Read the top rows as a generation-over-generation story. Terra beats its predecessor by 9.3 points on Agents' Last Exam, 17.1 on OSWorld 2.1, and 28.8 on Terminal-Bench 4.0. On OpenAI's adversarial factuality test, its error rate fell from 22.3% to 4.3% at max effort.
Read the price rows as the reason the top rows exist. Terra scores 60.0% on Agents' Last Exam against Sol's 58.6% — slightly ahead — at half the token price. Against Astra, OpenAI reports parity on the same benchmark at one-tenth the price per token, finishing tasks more than three times faster than both Astra and Sol.
Now the caveats. Artificial Analysis puts Terra's index at 48, four points behind Sol and ten behind Opus 5.5, so the parity claims don't survive an independent composite score. OpenAI's "nine times cheaper per task than Opus 5.5" figure also stacks a mid-tier model against a premium one, which makes a large ratio easy to produce. The direction is real; the magnitude deserves skepticism — and the way to settle it is running both models on your own tasks, which is what a multi-model workspace like Nolvia is for.
Why the New Price Point Changes the Math
At $1 input and $5 output per million tokens, Terra costs half of GPT-6.1 Sol and one-tenth of GPT-6 Astra. Cached input runs $0.05 per million. Against GPT-5.6 Terra, input dropped 50% and output roughly 58%.
That ratio hits agent workloads harder than chat. Computer-use agents are input-heavy: every step resends screenshots, DOM state, tool outputs, and logs. A chat turn might be 2,000 input tokens and 800 output; an agent step is often 20,000 input for 500 output. When input dominates, the input price is the budget.
Take a monthly load of 200M input tokens and 20M output tokens — a modest automation fleet:
| Model | Input cost | Output cost | Monthly total |
|---|---|---|---|
| GPT-6.1 Terra | $200 | $100 | $300 |
| GPT-6.1 Sol | $400 | $200 | $600 |
| Claude Opus 5.5 | $800 | $400 | $1,200 |
| GPT-6 Astra | $2,000 | $1,000 | $3,000 |
The same workload costs $3,600 a year more on Sol than on Terra. That's the difference between running one automation and running four.
One trap worth naming: cheap tokens don't guarantee cheap tasks. A tier with a lower per-token price that rambles, retries, or writes three times the output can cost more per completed job than a pricier model that finishes in one pass. Cost per successful outcome is the only number that matters, and it's the one vendors publish least often — a reason to measure it on your own tasks, which Nolvia makes practical by keeping Terra, Sol, and Opus 5.5 in one subscription.
What Changes in Practice for Agent Builders
Three practical shifts follow from the pricing.
Retries become affordable. The cheapest way to make an agent reliable is to let it verify its own work and try again. On an Astra-priced model, a three-attempt loop is a budget conversation. On Terra, measured at $0.40 per task by Artificial Analysis, it isn't. Teams that previously capped attempts to control spend can now build real self-correction into the loop.
Reasoning effort becomes a tuning knob. Terra exposes low, medium, and max effort, and the spread is wide — the factual error rate moves from 16.7% at low effort to 4.3% at max. That's a dial you can set per task: low effort for form filling on clean input, max effort for technical drawings where a misread dimension ruins the output.
Speed opens up interactive automation. OpenAI reports Terra finishing Agents' Last Exam tasks more than three times faster than Astra and Sol, which changes what's feasible when a human is watching the agent work.
The guardrail advice doesn't change. Keep acceptance checks on anything unattended, log every action so failures are replayable, and sandbox the first run of any new workflow. Terra's error rate is lower than its predecessor's, not zero — and with Nolvia you can hand the one risky step to a stronger model without switching tools mid-project.
Where Terra Still Falls Short
Hard coding is still Sol and Astra territory. Terminal-Bench 4.0 puts Terra at 50.3%, Sol at 55.9%, and Astra at 58.2%, and OpenAI says so directly in its own guidance. If your agent writes and refactors production code, Terra is the wrong tier.
Access is narrower than the pricing suggests. At launch Terra is available through the API, in ChatGPT Work and Codex for Plus, Pro, Enterprise, and Edu subscribers, and in Microsoft Azure AI Foundry. It isn't selectable in the standard ChatGPT chat interface, so anyone testing it casually in a browser tab will be disappointed.
There's also a positioning problem OpenAI created by shipping tiers weeks apart. Luna, Sol, and Terra now post overlapping scores on individual benchmarks, and developers reacted bluntly — why pick Terra over Sol, or over Opus 5.5? The honest answer is volume, not capability, and the way to confirm it for your workload is running Terra and Sol on the same task inside Nolvia.
Who Should Switch Now, and Who Should Wait
Switch now if you run high-volume screen, document, or form workflows. Invoice keying, catalog matching, form filling, frame-by-frame video QC, drawing-to-model conversion — Terra is built for this, at half of what GPT-5.6 Terra cost. If your prompts already work on 5.6 Terra, it's close to a drop-in change with a lower bill.
Switch now if you're paying Sol prices for routine agent loops. Most agent steps are visual pattern-matching with light reasoning. Moving the bulk of that traffic onto Terra and reserving Sol for the steps that need depth is the highest-leverage cost change available this quarter.
Wait if your work is frontier coding, long-horizon research, or anything where Opus-level reasoning is the actual requirement. A ten-point index gap doesn't close because the price is attractive.
Wait if you have no eval harness. Terra's advantages are economic, and you can't bank an economic advantage without measuring cost per successful task. Build a 30–50 task test set from real workload, run both models, and compare spend per passing task rather than per token. That number — not OpenAI's table — is your answer.
For a broader view of where coding models stand this quarter, our 2026 AI coding tools roundup covers the tiers that still beat Terra on engineering work.
Running Terra Alongside the Rest of the Field
No single subscription covers the four-tier lineup well. Terra is the value pick for automation, Sol is better for hard coding, and Opus 5.5 still leads independent reasoning scores — three bills and three interfaces if you buy them separately.
Nolvia takes a different approach: a browser-based workspace with GPT, Claude, Gemini, Grok, and 40+ models behind one subscription, switchable per message. For this decision, that means putting the same task in front of Terra and Sol back to back and deciding with evidence instead of a press release.
Nothing auto-selects a model for you, so nothing silently downgrades your request to a cheaper tier mid-project. You pick Terra for the invoice pipeline and Sol for the refactor.
Pricing runs $15/month for 45K points, $30/month for 100K points, and $60/month for 200K points — no API setup, no per-token invoices to reconcile. If you're still deciding whether the migration is worth the effort, testing both models on your own tasks beats building an eval pipeline from scratch.
Try Every Major AI Model in One Workspace
Nolvia gives you GPT, Claude, Gemini, Grok and 40+ models in a single subscription — no API keys, no juggling five tabs.
Start Free on Nolvia