Everyday work at half price: OpenAI's GPT-6.1 Terra is here, and computer use is now a volume business

On 26 October 2026, OpenAI released GPT-6.1 Terra. This is not a flagship upgrade; it is a pricing statement: a model that can operate a computer, read a screen, and write fluent text, now priced at $1 per million input tokens and $5 per million output tokens. For teams running hundreds or thousands of tasks a day, that matters more than any single benchmark score.

Terra has always been OpenAI's "middle tier": more capable than the cheapest Luna, cheaper than Sol and Astra. The 6.1 release redefines that middle tier. In the announcement's own words, it is aimed at "the communication and computer-based tasks that fill the workday" — drafting proposals, reading technical drawings, filling in forms, editing video. None of these jobs is hard on its own; the difficulty is volume, repetition, and low tolerance for error. Terra's selling point is not beating the flagship on one hard problem, but making this kind of work cheap enough to run in bulk.

What shipped: one model, three doors

From launch day, GPT-6.1 Terra was available in three places: ChatGPT Work and Codex (for Plus, Pro, Enterprise, and Edu users), the OpenAI API (as gpt-6.1-terra), and third-party channels that followed. One boundary matters: the announcement does not list the free tier of ChatGPT's chat tab, so "released" does not mean "available to you" until you check your own plan and entry point.

The hard specifications are worth noting too: a context window of about 1.05 million tokens, with roughly 922,000 input tokens and 128,000 output tokens; training data up to 1 June 2026; text and image input, text output; and reasoning effort adjustable from none to max. This is not a lightweight chat-only model, but a working model with reasoning settings and computer-use tools. The settings matter, as discussed below: on the same task, the error rate at low effort versus high effort can differ by tens of percentage points.

Price is the real headline of this announcement

Standard API pricing is $1 per million input tokens, $0.05 per million cached input tokens, and $5 per million output tokens. OpenAI's own comparison is that this is 50% below the standard prices of both GPT-5.6 Terra and GPT-6.1 Sol. Laid out as a ladder, the picture is clearer: Luna at $0.10 / $0.50, Terra at $1 / $5, Sol at $2 / $10, Astra at $10 / $50. Terra sits exactly at ten times Luna, half of Sol, and one-tenth of Astra.

For subscribers, the announcement says "your plan goes further" with Terra. That needs unpacking: it does not mean the plan got cheaper, but that within the same allowance, Terra completes more tasks than Sol or Astra. That is how the maths works for bulk invoice processing, form review, and first-draft generation. The reverse also holds: if you run only a few tasks, halving the per-token price barely moves your monthly bill, so do not switch models just because it is "cheaper".

There is also a pricing detail that is easy to miss: long prompts carry a surcharge. Third-party readings of the API documentation note that requests over 272,000 input tokens are billed at higher multipliers. This detail is not in the announcement itself, but it matters a lot for the "stuff the whole manual in at once" style of use. When budgeting, do not just multiply token counts by $1 / $5; first check which band your prompt lengths fall into.

How to read the three benchmark numbers

The most eye-catching claim comes from Agents' Last Exam, a professional-task benchmark that includes turning architectural drawings into a 3D model and watching an animated film shot by shot to build a time-coded log for a restoration team. OpenAI says Terra at medium reasoning effort scores 15 percentage points higher than its predecessor at about one-third of the cost; against the flagship Astra, it "performs on par" on this test at one-tenth the price per token and completes tasks more than three times faster. All of these figures come from OpenAI's own testing, with no independent replication yet, so keep the words "on this one test" firmly attached to them.

The second set of numbers is coding ability. Terminal-Bench 4.0 tests fixing real problems from the command line, such as repairing a web page whose layout shifts as it loads. At maximum reasoning effort, Terra solves 50.3% of tasks, against 21.5% for its predecessor — more than double. But the announcement adds a sentence of its own: for the most complex coding tasks, Sol and Astra remain the better choice. That sentence is more honest than the score itself, and it draws the selection boundary: Terra is "good enough and cheap for everyday coding", not "able to solve the hardest problems too".

The third set of numbers matters most to ordinary users: the rate of hallucination-style factual errors. On OpenAI's internal benchmark of error-inducing prompts, the error rate at low reasoning effort fell from 53.6% with GPT-5.6 Terra to 16.7% with GPT-6.1 Terra, and at maximum effort from about 22% to 4.3%, close to Sol and Astra. This tells us two things: first, the reasoning setting is not decoration — money saved at low effort may be paid back in errors; second, even at maximum effort, a 4.3% error rate means roughly one error in every 25 attempts, so important results still need human checking.

Where Terra sits in the four-tier lineup

Line the four tiers up and the selection logic becomes clear. Luna is the cheapest everyday entry, for simple questions and light tasks; Terra is the "bulk work" tier, for computer use, visual understanding, documents, and mid-level coding; Sol is the high-intensity tier, for complex coding and deep research; Astra is the flagship, for the hardest tasks and the most quality-sensitive work. Terra's ambition is to let a batch of jobs that used to need Sol drop down to Terra, cutting total cost.

But the downgrade comes with conditions. One limitation is easy to skip: Terra does not support UAE inference residency, which organisations with residency requirements should confirm first. Free and Go users were also not on the launch list, while Business workspaces were covered gradually through release notes. Before selecting, check three things: your plan, your entry point, and your compliance requirements — missing any one of them can turn excitement into a dead end.

Who should switch, and who should wait

Three groups can try it right away: first, teams running bulk computer-use and document work every day, such as invoice entry, form processing, and screenshot review; second, existing GPT-5.6 Terra users, for whom this is a same-tier upgrade with the lowest migration cost; third, cost-sensitive individual developers with high task volumes, who can run bulk work on Terra and save budget for the genuinely hard tasks that still need Sol or Astra.

Three groups should wait: first, scenarios where a single mistake is expensive, such as critical production fixes or final legal and medical documents — run a small controlled comparison first; second, heavy long-context users, who should test pricing and performance above 272,000 tokens rather than trusting the headline price; third, users already using Terra through Copilot — this site previously published a piece on Terra's arrival in Copilot, and this article is about OpenAI's 26 October model release itself. Same model, different door; do not count it as two releases.

What the "Critical" safety label means

The announcement's safety section says Terra meets the Critical threshold in cybersecurity under OpenAI's Preparedness Framework, while keeping the protections developed for Astra. This sentence is often misread as either "this model is dangerous" or "this model is safe", and it is neither. Critical is the framework's highest risk-tier label: it means the model's cybersecurity capabilities are high enough to require the highest level of accompanying safeguards and controls, not that it has been misused.

For users, the practical meaning is more concrete: when giving Terra computer-use permissions, manage it like a very capable operator — least privilege, sandboxing, operation logs, and human confirmation for critical actions, none of which can be skipped. Once prices fall, the most likely failure is not the model itself but management getting lax "because it is cheap". The announcement also notes that Terra showed strong resistance in prompt-injection tests and is more likely to disclose its limits and blockers. Both are plus points, but not a free pass: deleting files, sending emails, and touching production data still need a human in the loop.

Before launch day: the Terra name is not new

The Terra name already existed for a generation. GPT-5.6 Terra was the previous model in the same tier, while GPT-6.1 Sol shipped about four weeks earlier as the higher tier. In other words, the 6.1 generation was filled in from the top down: Sol first, then Terra, refreshing the middle tier's price and capability together. Read on its own, Terra looks like an isolated price cut; read a month after Sol, it looks like the second punch of a combination — first let the market remember what Sol can do, then tell it that most jobs do not need to cost that much.

Another background detail is worth noting: before the official announcement, Terra had already surfaced as an unannounced model in some third-party evaluation configurations. That is not unusual — vendors, cloud providers, and evaluators often prepare ahead of announcements. For readers it means two things: first, some third-party data was already available on launch day, so you do not have to rely on the vendor alone; second, pre-announcement prices and parameters were only rumours until the announcement, and this article uses only the 26 October announcement for prices, tiers, and availability.

What "computer use" actually means in practice

The announcement summarises Terra's core as "visual reasoning + computer use + writing", but those words are too abstract until unpacked. Visual reasoning means understanding screens and images: dimension labels on technical drawings, merged cells in tables, changes across video frames. Computer use means acting on that understanding: clicking, filling in forms, editing documents, running workflows inside applications. Writing means turning the result into text that can be handed over directly: first drafts of proposals, meeting notes, repair logs.

Agents' Last Exam was chosen as the headline benchmark because it tests the full chain from understanding to completion, not a single skill. Turning a drawing into a 3D model requires reading the drawing, operating modelling software step by step, and delivering a usable file; building a restoration log from a film requires watching, noting timecodes, and writing at the same time. These jobs are everywhere in real offices, yet hard to measure with traditional multiple-choice benchmarks. Terra's progress here shows it is aimed at "the work nobody wants to do every day but somebody has to do". Conversely, if your work is pure text reasoning, pure maths, or frontier research, this benchmark score has limited relevance — look at Terminal-Bench and the science benchmarks instead, not just the computer-use headline.

OSWorld 2.1 is a second piece of evidence: it tests multi-step tasks inside desktop applications. OpenAI says Terra at medium effort beats its predecessor's best score at a fraction of the cost per task, where "cost" means the token cost of completing the task, not the subscription fee. Read together, the two benchmarks point the same way: Terra's gains are concentrated in "medium-difficulty, multi-step tasks with a clear endpoint", not in "open-ended creative tasks with no standard answer". Match the task type to the model, rather than picking by brand name.

A migration checklist for vibe developers

If you already use GPT-5.6 Terra, or are considering downgrading a batch of jobs from Sol to Terra, this checklist can be followed directly. First, swap the model identifier: change the model name in your API calls to gpt-6.1-terra, leave everything else untouched, and run a small batch of real tasks as a comparison. The point is to isolate variables: confirm the model itself first, then change other parameters. Second, tune the reasoning setting: start at the default medium effort, try high or max for error-sensitive tasks, try low for cost-sensitive ones, and record the error rate and bill for each setting instead of guessing.

Third, check the long-prompt pricing band. If your prompts often exceed 270,000 tokens, split or summarise first, so the surcharge does not eat the price cut. Fourth, use caching: repeated system prompts, documents, and examples should go through cached input, which costs one-twentieth of standard input — for agents that carry context every turn, caching often saves more than the model price cut itself. Fifth, build a minimal evaluation set: pick 20 to 50 real tasks covering the most common success cases and the most error-prone cases, and run them every time you change the model, the setting, or the prompt, recording error rate and cost together. Migrating without an evaluation set is essentially switching models on luck.

Sixth, tighten permissions before loosening them. When Terra gets computer-use access, give it only the minimum it needs: read-only directories, test accounts, sandboxed environments. After two stable weeks with acceptable error rates and no out-of-scope behaviour, widen access gradually. The most tempting mindset when prices fall is "it is cheap, so give it more permissions to save trouble" — and that is exactly where computer-use incidents most often start. Tokens are cheap; accidents are not.

What independent evaluations say: direction first, numbers second

Beyond the vendor's benchmarks, third-party evaluations point broadly the same way, though their numbers use different methodologies and must be read separately. According to third-party summaries, Artificial Analysis scored Terra's maximum-reasoning version at about 48 on its composite index, between the previous Terra and Sol, with a per-task cost of roughly $0.40. These figures come from a third party's public summaries, not from OpenAI's announcement, and should be cited with their source and test version, since scores and costs can vary several-fold across reasoning settings.

Another kind of independent signal comes from developers' hands-on notes: some found Terra claiming completion before finishing all steps of a long task, and others found large performance swings across reasoning settings. Individual cases do not overturn benchmark scores, but they highlight something benchmarks do not measure: persistence and honesty on long tasks — whether the model finishes the job, or merely reports it as finished. For computer-use work, the latter is more dangerous, because a job that "looks done" is the most likely to flow straight into downstream processes. Adding a self-check step at the end of Terra's tasks — asking it to list completed and uncompleted steps, with key screenshots or log excerpts — costs little and prevents a lot of trouble.

Verdict: cheap really means "in volume"

What Terra really changes is not the quality ceiling of a single conversation, but the economics of bulk work. When a model becomes cheap enough to "just run it first and check later", working methods change with it: jobs once too expensive to automate can be automated first and reviewed after; volumes once only sampled can be run in full. But that change has a precondition: your process must include a review step. An error rate falling from 53.6% to 16.7% is huge progress, but 16.7% is still not a "ship it directly" number.

So the fairest assessment of Terra is this: a sincerely priced middle tier, and a bulk tool that needs a process around it. Start with your most repetitive, most standardised, easiest-to-spot-when-wrong batch of tasks, run it for a month, compare error rates and bills, and only then decide whether to expand. A model launch takes one day; the comparison data from the following month is what is actually worth money.