OpenAI releases GPT-6.1 Terra with visual reasoning and computer use

OpenAI shipped GPT-6.1 Terra, a mid-tier model that handles vision, image reasoning, and computer use (clicking through software on its own). It's priced at $1 per million input tokens and $5 per million output tokens. That's half what the prior Terra and the top-tier Sol cost, and about ten times the cheapest Luna. OpenAI's Ted Sanders claims it matches the expensive models on vision and computer use but runs much faster.

The price cut is real. At $1/$5, OpenAI is saying the cost of running a model that both sees and acts has dropped enough to halve the price and still make money. That's an efficiency signal: better chip utilization, likely a leaner vision pathway. The pressure lands directly on Anthropic's Claude Sonnet tier, which sits at $3 input / $15 output and owns exactly this slot. Developers buying high-volume automation treat these models as largely interchangeable. When a competitor halves your anchor price, you either match or bleed share.

The practical question for anyone building with these tools is whether Terra's price drop is far enough to replace the brittle Playwright or Selenium scripts you're running today. It might be. But "similar performance, much faster" is carrying the whole announcement, and faster tokens per second is not the same as faster task completion. A model that retries a dropdown three times is slower where it counts.

The bigger concern is what computer use actually means in production. A model that generates text can embarrass you. A model that clicks, types, and navigates can delete a record, approve a payment, or email a file to the wrong place. Terra is sold for automated, repetitive work, which means less human oversight by design. Prompt injection through on-screen content is still unsolved: a webpage can tell the agent to do something other than its task, and the agent can't reliably tell the difference. Anyone pointing this at a live workflow without a sandbox and a full action log is buying an incident.

Before shipping anything real: run your top five actual computer-use tasks ten times each and count clean completions. Public benchmarks like OSWorld and WebArena have coverage gaps; your procurement portal is not the benchmark. Build the action log and the rollback before you build the pipeline.

The call: Within 60 days, by late December 2026, Anthropic cuts Claude Sonnet-tier input pricing to $3 per million tokens or below, or releases a new Sonnet-class model at that price or lower. Medium confidence. Anthropic has matched OpenAI price moves on this tier before, and the mid-tier is bought on cost-per-task. The only scenario where Anthropic holds at $3/$15 is if Terra's computer-use reliability visibly disappoints in production, and Anthropic won't wait for that evidence to show up before defending share.

OpenAI shipped GPT-6.1 Terra, a middle-of-the-lineup model that sees images, reasons over them, and operates software on its own. It costs $1 per million words in, $5 per million words out. That's half what the prior Terra and the top-tier Sol cost, and about ten times what the cheapest Luna costs. The pitch, from OpenAI's Ted Sanders, is that it matches the expensive models on vision and computer use but runs much faster.

What's actually being decided for anyone building with these tools: whether the price of an AI that can click through a browser and fill in forms has dropped far enough to replace the brittle scripts you run today. This is easy to undo. It's an API call with per-token billing, no contract, no lock-in. So the deliberation should be fast and the testing should be real. Nothing sets a deadline here except your competitors doing the same math.

The Skeptic. "Similar on vision and computer use but much faster" is carrying the whole announcement, and Sanders never says faster at what. Tokens per second is not the same as finishing a task. A computer-use agent that's twice as fast per step but retries three times on a dropdown it can't parse is slower where it counts. The gap between passing a public computer-use test and navigating your actual procurement portal without inventing a purchase-order number is enormous. And six models now, Terra, Sol, Luna, Astra and the rest, is a pricing ladder built to capture every willingness-to-pay, not proof that capability neatly splits into tiers.

The Safety Lens. A model that generates text can embarrass you. A model that clicks, types, and navigates can delete a record, approve a payment, or email a file to the wrong place. Terra is sold for "automated, repetitive" work, which means less human watching by design. Prompt injection through what's on the screen is still unsolved: a webpage can carry text that tells the agent to do something other than its task, and the agent can't reliably tell the difference. OpenAI's public evidence on computer-use safety is thin. Anyone pointing this at a real workflow without a sandbox and a full log of every action it took is buying an incident.

The Researcher. Speed on computer-use tasks is the more interesting signal in this announcement. In an agent loop, where the model acts, reads the result, and acts again, latency compounds step over step. A model that's genuinely faster per step changes how many tasks finish inside a reasonable window. But "better than Sol at technical communication" needs adversarial testing before anyone believes it. The public benchmarks for computer use, OSWorld and WebArena, have real coverage gaps, so a good score there tells you less than it looks. Test it on your own software, not on a leaderboard.

The Compute Pragmatist. At $1 in and $5 out, OpenAI is saying the cost of running a mid-tier model that both sees and acts has dropped enough to halve the price and still make money. That's an efficiency signal, probably better use of the chips plus a leaner vision pathway given the "much faster" claim. The pressure lands on Anthropic's Sonnet tier, which sits in exactly this slot. It also squeezes the cloud providers who host rival models: every time OpenAI drops the anchor price, the margin on third-party inference at AWS, Azure, and Google Cloud gets thinner.

The Builder. On Tuesday morning this reprices every browser-automation hack you're running. Teams duct-taping Playwright or Selenium scripts to fill forms, pull dashboards, or clear a video-editing queue should rerun the build-versus-buy math now. What breaks first in production is reliability on weird interface states. These models hallucinate clicks on dynamic pages and fail quietly: they assume an action worked and move on. The second thing nobody stress-tests in week one is how the model behaves deep into a long session, when the context fills and rate limits bite. Build the action log and the rollback before you build the pipeline.

Where they disagree. The Compute Pragmatist and the Skeptic split on what the price cut proves. One reads it as the cost curve genuinely bending, which forces Anthropic's hand. The other reads it as a pricing ladder that makes a model look cheap next to Sol while still charging ten times Luna for work that may not need vision at all. Both can be right: the cost to serve really did fall, and the lineup is still engineered to extract more money per customer.

The deeper tension is between the Builder's "ship it, the economics changed" and the Safety Lens's "you're automating actions you can't take back." That's the real decision. The question isn't whether Terra is capable. It's whether the task you're pointing it at is one where a silent failure costs you a log line or a deleted invoice.

What this hinges on. Three things. Does "much faster" mean faster task completion including retries, or just more tokens per second? Does the computer-use reliability hold on your own software, not a benchmark? And can you contain a wrong action when, not if, it happens? Verify them in that order. Build a small test harness that runs your top five real computer-use tasks ten times each and counts clean completions, not demos. Put every action behind a sandbox and a log before anything touches a live system.

Prediction: Within 60 days, by late December 2026, Anthropic will cut the price of its Claude Sonnet tier or release a new Sonnet-class model priced at or below $3 per million input tokens, down from its current $3 input / $15 output.

Confidence: Medium — Terra attacks Sonnet's exact price-and-capability slot, and Anthropic has matched OpenAI price moves before.

Why: Terra lands squarely in the mid-tier slot Anthropic's Sonnet owns, at $1 input / $5 output against Sonnet's $3 / $15, and it claims the same vision and computer-use capabilities that are Sonnet's selling points. When a competitor halves the anchor price in your core tier, you either match on price or lose developers who treat these models as swappable, which most API buyers do for high-volume automation. Anthropic responded to prior OpenAI price moves on the Sonnet line rather than holding a premium, because the mid-tier is bought on cost-per-task, not brand. The less likely outcome is Anthropic holding Sonnet pricing flat and betting that reliability keeps developers paying triple, but that bet only works if Terra's computer-use reliability visibly disappoints, and Anthropic won't wait for that evidence before defending share.

Revisit by 2026-12-31: We're right if Anthropic cuts Sonnet-tier input pricing to $3/million or below, or ships a new Sonnet-class model at that price or lower. We're wrong if Sonnet-tier input pricing stays above $3/million with no new lower-priced Sonnet-class model released.