GPT-6.1 Terra Makes Screen Automation Cheaper to Try. The Pilot Still Has to Pass.

TL;DR: OpenAI released GPT-6.1 Terra on October 26 for the API, ChatGPT Work, and Codex.^[1] Standard API rates are $1 per million input tokens, $0.05 per million cached input tokens, and $5 per million output tokens; API usage is billed separately from a ChatGPT subscription.^[2] For screen automation, the useful question is how many tasks reach a verified result within a measured cost and correction budget, not which vendor chart looks best.

An invoice arrives as a PDF. Someone reads the supplier and totals, opens an accounting screen, copies the fields, and checks the result. OpenAI's October 26 Terra release explicitly proposes work like this as a use case for its lower-priced computer-use model.^[1] The release is worth attention because the labor is repetitive and the software often lacks a clean integration.

The real story isn't a model that can click. It is whether an organization can buy a reliable completed transaction, rather than a stream of plausible screen actions. Terra changes the price of trying. It does not make a mistaken supplier, duplicate invoice, or silent form submission cheap to correct.

Cover: generated conceptual artwork of a screen workflow and token ledger. It is not an OpenAI product screenshot or test result.

The Release: A Price Cut Meets a Product Boundary

Terra is available as gpt-6.1-terra in the API and as a selectable model in ChatGPT Work and Codex. OpenAI positions it for visual reasoning, precise computer use, and writing.^[1] Its release notes specify that Terra is in Work and Codex, not regular Chat, and that API use is billed separately from ChatGPT subscriptions.^[2] That distinction determines how a pilot is budgeted and who can run it.

The launch announcement names Plus, Pro, Enterprise, and Edu access in Work and Codex.^[1] OpenAI's October 26 Business release notes also state that Terra can be used in Business Work and Codex as rollout reaches a workspace, subject to its seat and permissions.^[4] An administrator should inspect the model picker and permissions in the intended workspace instead of treating the launch list as an enduring entitlement table. The same release notes say Terra does not support UAE inference residency; the restriction concerns where inference runs, not where the user sits.^[2]

Here is the genius of the pricing move: the published standard API rate separates input, cached input, and output. That gives a team a clear starting formula for a budget. OpenAI's pricing table lists $1, $0.05, and $5 per million tokens respectively.^[3] Those are token rates, not the price of completing an invoice, and they do not cover every possible tool or infrastructure charge.

The Cost: Compute an Example, Then Measure the Real Run

Consider an illustrative run consuming 20,000 uncached input tokens and 5,000 output tokens at standard API rates. Input costs $0.020; output costs $0.025; their sum is $0.045. If 100 identical runs used those exact token amounts, model token charges would be $4.50. This is arithmetic from the published rate card, not an observed Terra invoice workflow or a forecast of its token consumption.^[3]

Caching changes the arithmetic only when the input actually qualifies. In a separate hypothetical run with 10,000 uncached input tokens, 10,000 cached input tokens, and 5,000 output tokens, model token charges are $0.010 + $0.0005 + $0.025 = $0.0355. A workflow that revisits screenshots, retries failed actions, or asks for human review may consume many more tokens and minutes. Tool charges, external software, operator time, and correction labor belong in the full cost ledger. The price table is a billing input, not an end-to-end unit-economics result.^[3]

OpenAI says Terra's standard API prices are 50% below GPT-5.6 Terra and GPT-6.1 Sol and reports advantages on its own professional-task and computer-use evaluations.^[1] Those claims are useful deployment signals, not a direct ranking of your invoice task. Published figures do not normalize your model settings, hardware, image and prompt lengths, output lengths, decoding, speculative-decoding acceptance, batch or concurrency, time to first token, tail latency, and harness. Even if a benchmark uses a defined reasoning effort, its environment is not your accounting application. Keep its results attributed to OpenAI and measure your own task distribution.

The Pilot: Make One Screen Task Auditable

Start with a nonfinancial, reversible task such as moving a small set of approved catalog descriptions from a source sheet into a staging content-management screen. Use synthetic records and a staging account with no publication permission. The objective is narrow: for each item, copy the approved title, description, and category, then save a draft. A reviewer compares the saved draft with the source before any later publication. This tests reading, navigation, field entry, and verification without assigning the model authority over payments or customer records.

Define acceptance before the run. For example, require zero wrong-category saves, zero unapproved publishes, and at least 95 accepted drafts out of 100 after independent review. Cap each item at two retries and record every intervention. These are proposed thresholds for this particular low-stakes pilot, not a published benchmark or a universal safety standard. If the agent loses context or reaches its action cap, it should leave the item as a draft or untouched and hand the source record, attempted actions, and error to a human. That fallback is part of the workflow, not an embarrassment to hide in an average.

OpenAI's API guide recommends starting Terra at medium reasoning effort and moving higher only if quality gains justify more time and tokens. For tool calls, it directs developers migrating from Chat Completions to use the Responses API; OpenAI's computer-use guide describes the action and screenshot loop.^[5][6] Hold those choices constant during a comparison. If you change reasoning effort or UI tool behavior mid-pilot, treat the result as a new configuration, not the same run made better by magic.

The Evidence: A Vendor Benchmark Is a Starting Hypothesis

OpenAI reports that at medium effort Terra scored 15 percentage points above GPT-5.6 Terra on Agents' Last Exam at about one-third the cost. It also reports gains on OSWorld 2.1 and an internal factuality benchmark.^[1] These are OpenAI's measurements. They are not independent proof that a catalog draft will be correct, that the model will recover from a modal dialog, or that the per-task cost in your environment will match the vendor's estimate.

What's often overlooked is the denominator. A cost per successful task needs to include failed attempts, retries, human inspection, and cleanup. Report accepted drafts per 100 assigned items, median and tail completion time, model and tool spend, and minutes of correction. A lower token bill paired with twice as many corrections is not an economic improvement. OpenAI's model-selection guidance likewise advises choosing models against the application's task and tradeoffs rather than a single general score.^[8]

The October 26 Terra system-card addendum documents OpenAI's own safety evaluations, including robustness and preparedness work.^[7] It does not certify that a team has permission to operate a particular application or that every visual action is safe. The uncomfortable truth is that screen automation inherits the privileges of the account it controls. A staging account, narrow permissions, action log, and human acceptance point are product design decisions, regardless of the model's published safety assessment.

The Decision: Buy Verified Work, Not Screen Motion

Let's be clear: Terra's release is a credible reason to retest workflows that previously looked too expensive to automate. It is not evidence that a team should turn on unattended production access. The API price makes experimentation inexpensive in token terms; the real purchase is a repeatable, reviewed result.

If the staging pilot reaches its pre-set acceptance rate within a measured cost and correction budget, widen the task one permission at a time. If it fails, keep the human process, redesign the UI boundary, or use a structured integration where one exists. The strategic advantage will go to teams that can turn cheaper model calls into verified work without outsourcing accountability to a benchmark chart.

Last updated: October 31, 2026