OpenAI has introduced GPT-6.1 Terra and, as usual, the telling bit isn't the model itself: it's what they chose to put in the opening paragraph of the announcement. This time it's visual reasoning and computer use. No maths, no code, no exam records.
What happened
The short version, as recorded in Simon Willison's note:
- Terra is sold as a fast, efficient model that reads images in detail, drives a computer precisely and writes more naturally. OpenAI's examples are pure office work: drafting proposals, reading technical drawings, filling in forms, editing video.
- Pricing: one dollar per million input tokens and five per million output tokens.
- That's nearly half what GPT-5.6 Terra and GPT-6.1 Sol cost, and roughly ten times the cost of GPT-6 Luna.
- The line-up now has four pieces: Astra and Luna on one side, Sol and Terra on the other, with two version numbers living side by side.
- On the pelican riding a bicycle test at maximum reasoning, the drawing came out at 11.3161 cents and took four minutes eleven seconds.
Ted Sanders, from OpenAI, added nuance in a public comment: Terra comes out ahead of Astra and Sol on technical communication, sits at a similar level on vision and computer use —but much quicker— and gives up a little on most other things. For API users, a middle option: cheaper than Sol, considerably more capable than Luna. For subscribers, not much.
Why it matters
The bit that interests me is computer use, because that's exactly the task where the expensive model doesn't pay for itself. An agent that fills in a form, downloads a report and pastes it into another screen doesn't need brilliance: it needs to not get it wrong and to finish quickly. And it'll do it two hundred times a day.
There, speed isn't a comfort detail, it's the metric. Four minutes eleven seconds for a pelican sounds like a fun anecdote; multiply it by an agent loop with twenty steps and it stops being funny. If you've got an automated process in production, the right question isn't "which model scores highest?" but "how many seconds and how many output tokens does one full pass cost me?".
And here's the trap with per-token pricing. Terra costing half of Sol doesn't mean your bill halves. A cheaper model that needs more reasoning steps to reach the same place can work out just as expensive, or worse. Your real cost comes from the reasoning level you end up using, not from the number in the pricing table. If you're going to move, the honest way to decide is to take a sample of your real cases, run it through both models and compare three columns: correct answers, output tokens and seconds. That's an afternoon's work.
What someone would do differently from today: on repetitive interface work, start at the bottom. Try the cheap model first, measure the failure rate, and only move up a rung where failure actually hurts. The opposite —putting the big model everywhere "just in case"— is the quietest way I know of burning a budget.
What doesn't change
This isn't a capability jump, and it's worth saying because the announcement doesn't. OpenAI admits it through one of its own people: on most things, Terra sits slightly behind. It's a catalogue move, not a frontier one.
Nor does anything change for people on a subscription rather than the API. If you keep hitting usage limits, you might stretch a bit further. Not much more than that.
And the pelican isn't a benchmark. It's a homemade test, entertaining and genuinely revealing about how a model draws, but nobody should pick an architecture from it. It's good for what it's good for: comparing cost and time across reasoning levels on the same job.
Our take
I prefer this kind of release to frontier ones, and I'll defend that: speed is a capability, not a finish. A model that does what the big one does in half the time opens up use cases the big one had closed off, because plenty of processes simply can't take four minutes of waiting per step. For real business work, that's worth more than two points on a maths exam.
What I dislike is the naming. Four live models, two version numberings and proper names that order nothing: nobody can work out from "Terra" whether it sits above or below "Sol". OpenAI doesn't pay the cost of that — you do, eighteen months from now, when you open a repository and find the model name hardcoded in four places with no comment explaining why that one was picked. I've seen it already with ordinary API versions, and it'll happen here too, only faster.
So here's my bet on how this ages: the model has months of commercial life, not years. Don't rewrite anything around Terra. Keep the model name in configuration, not in code; log which model answered each request; and keep a set of your own test cases ready to fire at the next release the day it lands. Do that and every price cut becomes your gain instead of an afternoon of panic.
On the projects where we put AI inside a company process, the hard part is never picking a model: it's having the process written down somewhere and someone able to measure whether the machine does it properly. Once that exists, swapping models is a one-line change.
Any questions, tell me and we'll look at it.
All the best, Vicente.