GPT-6.1 Terra for computer use: a worker seat in the agent stack, not the reviewer's
A mid-tier model earns its price where the result is cheap to check before it matters. Terra's benchmarks measure cost per task; the number that decides computer use is what a wrong click costs, and OpenAI's chart has no axis for it.
Contents
OpenAI released GPT-6.1 Terra on October 26 as “a fast, efficient model that combines detailed visual reasoning and precise computer use.” It costs $1 per million input tokens, $0.05 cached and $5 output. It is in the API as gpt-6.1-terra and in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu.
The launch post sells Terra on cost per task. For computer use I’d look at a different number first: what one wrong action costs you, and whether you can catch it before it counts.
What does GPT-6.1 Terra cost next to Claude and GPT-6 Luna?
Half of Claude Sonnet 5.5, a quarter of Opus 5.5, ten times Haiku 5.5. Per million tokens, Terra is $1 in and $5 out. Sonnet 5.5 lists $2 and $10, Opus 5.5 $4 and $20 (the full Claude table), and Haiku 5.5 $0.10 and $0.50 below its 100K line, the same card as GPT-6 Luna. Terra’s cached input at $0.05 is half Sonnet’s $0.10 cache read.
Inside OpenAI’s lineup it is half the price of GPT-6.1 Sol and a tenth of GPT-6 Astra. Simon Willison puts it where Sonnet sits at Anthropic: “not the cheapest or the most expensive, making it harder to decide when to use it.” At this price it’s half a Sonnet.
What does OpenAI claim about GPT-6.1 Terra’s computer use?
Astra-level scores at one-tenth Astra’s per-token price, by OpenAI’s own chart. On Agents’ Last Exam, a benchmark of professional tasks such as turning architectural drawings into a 3D model, OpenAI says Terra at medium effort scores 15 percentage points higher than GPT-5.6 Terra “at about one-third the cost” and “on par with GPT-6 Astra.” At max effort it is “over three times as token efficient as Claude Opus 5.5,” with “a ~9x lower cost per task,” and it finishes tasks more than three times faster than Astra and Sol.
MMMU-Pro (visual reasoning) and OSWorld 2.1 tell the same story. On Terminal-Bench 4.0 Terra solves 50.3% at max effort, against 21.5% for GPT-5.6 Terra, though OpenAI says Sol and Astra “remain the better choice” for the hardest coding. Ted Sanders from OpenAI was blunter in a Hacker News comment that Simon Willison quoted:
Terra is probably 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.Which GPT-6.1 Terra claims can you check today?
The prices. Agents’ Last Exam appears as a chart with no table, the speed claim has no absolute timings, and the error-rate result (53.6% down to 16.7% at low effort) is from “our internal benchmark of error-inducing prompts,” and the post doesn’t publish enough of it to rerun.
You can check whether the Opus comparison multiplies out. If “over three times as token efficient” applied to the whole bill, a quarter of the price would make it over 12x. If it saved no tokens at all, the price gap alone gives 4x. OpenAI’s ~9x sits between, so on this arithmetic the efficiency doesn’t cover the whole bill, and the announcement doesn’t say which part it does. I’d plan for anything from 4x to 12x. A computer-use loop resends a screenshot every step, so count your own input tokens per step first.
What does GPT-6.1 Terra change for an agent stack?
A second vendor’s mid-tier model is now competitive on screen work, with a hazard rating attached. OpenAI says Terra “meets the Critical threshold in cybersecurity under our Preparedness Framework” and keeps the protections built for GPT-6 Astra. The threshold rates what the model can do in cyber, and that rating is why Astra’s safeguards ship with it. On prompt injection the announcement says “strong resistance” and points to the system card for detail. For an agent that reads arbitrary pages, that section is the one to read before the benchmark chart.
Look at the tasks OpenAI chose. Drawings turned into a 3D model, a shot-by-shot log for a restoration team, and its own example of reading incoming invoices and entering them into accounting software. Every one produces an output you can check against its source before anyone acts on it. On a benchmark a failed task costs points. In a logged-in account, a click that sends a message or changes a setting has already done its work by the time you can check it, and a cost-versus-score chart has no axis for that.
Where does GPT-6.1 Terra fit, in my read?
In the worker seat, for jobs where the check comes before the consequence: form filling and extraction from screens, with a stronger model or a validation step reading the result before it is posted. The argument rests on checkability; “a bit worse” can’t carry it. I’ve argued before that the reviewer’s chair goes to the model that doubts more, and nothing in the launch says whether Terra is that model. It says Terra is cheap, fast and good at screens, which describes a worker you can afford to double-check.
Whether that worker should be OpenAI’s is a separate question. If your stack runs on Claude, Terra at half Sonnet’s price is a saving, but a second vendor buys you a second bill and a second cache to keep warm. Keep the split by role. A reviewer reading the worker’s output in its own conversation loses nothing, while a router that swaps models mid-conversation can drop the reasoning it carried. My guess is the second integration pays for itself on a high-volume job and not on an occasional one.
If you try Terra in an agent, pick a task whose output you can diff against a source before it is used, run it at medium effort, and log input tokens per step before trusting the 9x. The chart prices a failed task at a lower score. Your logs price it in whatever the wrong click touched.
01 / Discussion
No comment section here — all discussions happen on X.
02 / More articles
OpenAI's no-internet rule for frontier training: the approved services were the way out, and agent sandboxes should copy the split
The copy of the web held. What OpenAI's own red team found a way through was almost every service left connected for running the lab, and the September escape went through a resolver no copy replaced. Serve the agent's work from copies, keep the live connections few and outside its reach, and expect the cost to land on github.com.
Vox's AGENTS.md lines, tested in 90 Claude Code runs: the line that worked best wasn't one of his
Line one made the agent leave out the input check. Line two's extras disappeared when line one shared the file. 'Without breaking anything' showed no clear effect beyond what a named test command already did. What 90 runs can and cannot say, and how to test a line before you keep it.
Attack surface reduction with Claude Code: Anthropic's three passes on my own site, and a fourth they don't ask
The skill is not out, the method rebuilds in an afternoon, and the hard part is choosing where to point it. Here the most useful result was a broken verification file, and the exposure that mattered lived in a deploy setting my three passes never opened.