OpenAI GPT-6.1 Terra: Half-Price AI That Uses Your Computer — Features, Pricing, vs Sol and Astra (October 2026)

A computer-use AI agent operating a desktop computer — the core idea behind GPT-6.1 Terra. (AI-generated illustration)

On October 26, 2026, OpenAI quietly added a new member to its flagship lineup: GPT-6.1 Terra, a model the company describes as built for "computer use." It is not the biggest or most expensive model in the family. It is the opposite — a model whose headline feature is price. GPT-6.1 Terra launched on October 26, 2026, with API pricing of $1 per million input tokens and $5 per million output tokens, which OpenAI positions as roughly half the price of GPT-5.6 Terra and GPT-6.1 Sol.

That positioning matters because of what Terra is designed to do. This is not a chat model tuned mainly to write essays or answer trivia. OpenAI built Terra to operate a computer the way a person would: reading what is on the screen, clicking buttons, filling in forms, processing invoices, and even helping edit video. In industry language these are called "computer use" agents or "agentic" models — systems that do not just answer questions but take actions across software. Terra is OpenAI's attempt to make that kind of agent cheap enough to run all day, every day.

Why would a cheaper model be news? Because agentic work is expensive in a very specific way. Every click, every screenshot check, every retry costs tokens, and agents burn through tokens fast — dozens or hundreds of model calls for a single completed task. When each call costs money, running an agent on real business work gets expensive quickly. A model that OpenAI says delivers roughly Astra-level quality at a tenth of Astra's per-token price would change the economics of automation for small teams, startups, and individual developers. Every performance and price claim in this article is OpenAI's claim, not an independently verified benchmark — treat the numbers below as the company's marketing position until independent testing confirms them.

In this guide, we explain GPT-6.1 Terra from zero: what "computer use" actually means in plain language, what the model can and cannot do, exactly what it costs, how it compares to GPT-6.1 Sol and Anthropic's Astra, who should use it, who should not, and how to get started. We cite every key fact to its source, and we clearly separate what is verified from what is claimed.

Key Takeaways

• Launched October 26, 2026: GPT-6.1 Terra is OpenAI's newest model, available in ChatGPT Work and Codex for Plus, Pro, Enterprise, and Edu tiers, and via API as gpt-6.1-terra.
• Half-price positioning: API pricing is $1 per million input tokens and $5 per million output tokens — a 50% cut versus GPT-5.6 Terra and GPT-6.1 Sol.
• Built for "computer use": the model is designed to read screens, fill forms, process invoices, and edit video — operating software like a person would.
• Large context window: 1.05 million tokens, enough to hold very long documents, codebases, or long agent sessions in memory at once.
• Same-day AWS launch: Terra launched on AWS Bedrock the same day it was announced, making it available to enterprise cloud teams immediately.
• Vendor claims, clearly labeled: OpenAI claims 3x faster task completion than Astra or Sol and roughly Astra-level quality at one-tenth the per-token price. These are OpenAI's claims, not independent results.
• Best for: developers and businesses running high-volume AI agents — invoice processing, form filling, data entry, automated QA — where token costs dominate.
• Not best for: anyone who needs the absolute highest reasoning quality regardless of price, or who needs independent proof of the benchmarks before spending.

What GPT-6.1 Terra Is

GPT-6.1 Terra is the newest model in OpenAI's GPT-6 generation, and the name tells you where it sits in the family. The "Terra" line is OpenAI's workhorse tier — models aimed at everyday, high-volume work rather than the most demanding reasoning tasks — while the "6.1" marks it as a refinement of the GPT-6 generation. The verified headline is simple: GPT-6.1 Terra is a cheaper, efficiency-focused model built to operate computers, launched October 26, 2026.

Where can you actually use it? Terra is available in two products on day one. First, in ChatGPT Work and in Codex, for customers on the Plus, Pro, Enterprise, and Edu tiers — so both individual subscribers and organizations get access. Second, through the OpenAI API, where developers call it with the model ID gpt-6.1-terra. The API route is where Terra's pricing matters most, because that is where businesses run agents at scale: thousands of automated tasks a day, each one consuming tokens.

There is also a third channel worth noting for enterprise buyers: Terra launched on AWS Bedrock the same day it was announced. AWS Bedrock is Amazon's managed service that lets companies use AI models inside their own AWS accounts with enterprise security, compliance, and billing controls. A same-day Bedrock launch is unusual and signals that OpenAI wants large corporate and government customers to adopt Terra immediately, inside the cloud infrastructure they already use, rather than waiting months for availability.

It helps to understand why OpenAI released a cheaper model at all. The AI industry spent 2024 and 2025 racing to build the smartest possible models, and prices for top-tier reasoning models stayed high. But the money in AI is increasingly in agents — software that does multi-step work on a user's behalf. Agents are token-hungry by design: they look at a screen, decide what to do, do it, check the result, and repeat, sometimes hundreds of times per task. A model that costs half as much per token can cut an agent's operating bill in half overnight, with no other changes. Terra is OpenAI's bid to own the economics of that agent workload, not just the intelligence race.

Think of the model lineup like cars. If the most powerful reasoning models are sports cars — fast, expensive, impressive — Terra is the delivery van: not built to win races, built to carry loads cheaply, reliably, all day. The interesting question the rest of this article answers is whether the delivery van can still handle the roads it is sold for.

What "Computer Use" Means, in Plain Language

The phrase "computer use" sounds vague, so let us make it concrete. A "computer use" model is an AI that can see your screen and operate your software the way you do: looking at what is displayed, moving the cursor, clicking buttons, typing into fields, scrolling pages, and reading the results. Instead of only chatting with you, it can open an application, do the work inside it, and report back.

Here is an example for a beginner. Imagine you receive 200 invoices by email every month, and each one needs its data typed into your accounting software: the supplier name, the invoice number, the date, the line items, the total. A person does this by opening the email, opening the invoice, reading it, opening the accounting app, and typing. A computer-use agent with Terra does the same loop automatically: it reads the invoice on screen, understands which field goes where, fills in the form, saves, and moves to the next one. No custom integration, no API for the accounting software — just the AI using the interface like a human employee would.

Four capabilities OpenAI names for Terra are worth unpacking one by one:

• Reading screens: the model can interpret what is visible in an application — text, buttons, menus, layout — so it knows the current state of the software it is operating. This is harder than it sounds: every app looks different, buttons move, pop-ups appear, and the model has to cope with all of it.
• Filling forms: taking structured information (a name, an address, a date) and putting it in the right fields on a web page or desktop app, then submitting. This is the backbone of data-entry automation.
• Processing invoices: reading semi-structured documents like bills and receipts, extracting the important fields, and entering or reconciling them. Invoice processing is one of the most common real-world agent workloads, which is why OpenAI names it explicitly.
• Editing video: the most surprising item on the list. Video editing means navigating an editing application — arranging clips on a timeline, trimming, adding transitions — which requires precise, sustained interaction with complex software. If Terra handles this well, it suggests the model is capable of long, multi-step tasks, not just quick form fills.

Why is this different from a normal chatbot? A normal chatbot lives inside a text box: you type, it replies. A computer-use agent lives inside your software: it perceives, decides, and acts, in a loop. The difference matters for cost. A chat answer might use one model call; a computer-use task can use dozens or hundreds of calls, because every glance at the screen and every action is a new request to the model. That multiplication is exactly why a model priced at half the usual rate is strategically important — it halves the bill for the most token-hungry kind of AI work.

It is also worth knowing the honest limits of this technology as a class, not just Terra. Computer-use agents can get confused by unusual screen layouts, unexpected pop-ups, or ambiguous buttons. They can make mistakes a careful human would not, like clicking the wrong row in a table. They are slower than a person at simple tasks and can be slower than a direct software integration (an API) at complex ones — an API moves data in milliseconds with no screen-reading at all. The right mental model: computer-use agents are for software that has no API, or where building an integration costs more than letting the AI click through the interface. Terra makes the "let the AI click" option cheaper; it does not make it perfect.

Key Features and Capabilities

What does GPT-6.1 Terra actually do well, according to what has been reported about the launch? The defining capability is agentic computer use — Terra is purpose-built to perceive screens, plan multi-step actions, and execute them inside real software. Let us break that down into the practical features that matter to a buyer or builder.

A 1.05-million-token context window. A "context window" is how much information the model can hold in its working memory at one time — the conversation so far, the documents you gave it, the screenshots it has seen, the code it is working with. One million tokens is roughly 750,000 English words, or about 1,500 pages of a book. A 1.05M-token window means Terra can keep an entire long agent session in memory: every screen it looked at, every action it took, every document involved, without forgetting the beginning. For computer-use work, where a task might involve dozens of screens and hundreds of steps, a huge context window is not a luxury — it is what lets the agent stay coherent over a long job.

Screen understanding and action. Terra is designed to read graphical interfaces: buttons, menus, form fields, tables, error dialogs. Combined with the ability to act — click, type, scroll, drag — this makes it a general-purpose operator for software that was never built for automation. Most business software in the world has no API. It was built for humans with mice. A model that can drive that software like a human unlocks automation for the long tail of applications that were previously off-limits to bots.

Long-horizon task execution. The video-editing example OpenAI names is significant because editing is not a five-second task. It involves importing media, arranging clips, trimming, adjusting audio, adding titles, and exporting — a sustained sequence where each step depends on the last. Naming video editing as a capability signals that Terra is aimed at tasks that take many steps and require persistence, not just quick lookups. Whether it does this reliably in practice is something independent testing will need to confirm.

Speed, as OpenAI claims it. OpenAI says Terra completes tasks 3x faster than Astra and Sol. Read that carefully: "task completion" speed for an agent is not the same as raw token-generation speed. It likely reflects a combination of faster inference and needing fewer steps to finish a job. OpenAI claims 3x faster task completion than Astra/Sol — this is a vendor claim, and no independent benchmark in our sources confirms it. Treat it as OpenAI's stated goal and marketing position, and look for third-party evaluations before budgeting around it.

Availability across ChatGPT Work, Codex, API, and AWS Bedrock. Terra is not an API-only experiment. It ships in ChatGPT Work (the business version of ChatGPT) and Codex (OpenAI's coding product) for Plus, Pro, Enterprise, and Edu customers, through the public API as gpt-6.1-terra, and on AWS Bedrock for enterprise cloud deployments. That breadth matters: it means an individual subscriber, a startup developer, and a Fortune 500 IT team can all reach the same model through the channel they already use.

GPT-6.1 Terra's headline promise: premium-style agent capability at half the price. (AI-generated illustration)

GPT-6.1 Terra Pricing, Explained

API pricing is where Terra makes its case, so let us walk through the numbers slowly, because token pricing confuses almost everyone at first. GPT-6.1 Terra costs $1 per million input tokens and $5 per million output tokens, with cached input at $0.05 per million tokens.

First, what is a token? A token is a chunk of text the model reads or writes — roughly, a word is about 1.3 tokens in English, so a million tokens is around 750,000 words. "Input tokens" are what you send the model: your prompt, the documents, the screenshots converted to data. "Output tokens" are what the model writes back: its reasoning, its answers, its action plans. Output almost always costs more than input, because generating text is the computationally expensive part — notice Terra's 5-to-1 ratio between output and input price.

What does this cost in real money? Imagine an agent that processes one invoice. Suppose the task consumes 50,000 input tokens (the invoice image, the instructions, the conversation history) and 5,000 output tokens (the extracted data and action decisions). At Terra's prices, that is $0.05 for input plus $0.025 for output — about seven and a half cents per invoice. Process 10,000 invoices a month and the model bill is roughly $750. On a model costing twice as much per token, the same workload is $1,500. That is the entire pitch: at agent scale, per-token price is the business model.

Then there is caching, which deserves its own explanation because it is where the biggest savings hide. Cached input costs just $0.05 per million tokens — one-twentieth the price of fresh input. Here is why that matters: agents repeat themselves. Every step of an agent's loop re-sends the same system instructions, the same background documents, the same conversation history. "Prompt caching" lets the provider reuse the computation for repeated input instead of redoing it, and charges you a fraction of the price. For long agent sessions where most of the input is repeated context, caching can cut the input bill dramatically — in the example above, if 80% of the input were cached, the input cost would drop from $0.05 to barely over $0.01 per invoice. When evaluating Terra, the cached-input price may matter more than the headline $1 figure.

Finally, the "50% price cut" framing: Terra is priced 50% below GPT-5.6 Terra and GPT-6.1 Sol. Working backward from Terra's $1/$5, that implies the two more expensive models sit at roughly $2 per million input tokens and $10 per million output tokens. OpenAI is positioning Terra as the value tier of the current generation: same generation's capabilities, tuned for efficiency, at half the price. Whether the quality trade-off is worth it depends on your workload — which is exactly what the comparison sections below are for.

Terra vs GPT-6.1 Sol: The Sibling Rivalry

GPT-6.1 Terra and GPT-6.1 Sol are from the same generation and the same company, so the comparison is really about positioning: OpenAI sells both, and wants you to pick the right one for each job. The verified difference is price: Terra costs 50% less than Sol — roughly $1/$5 per million tokens versus Sol's implied $2/$10.

Think of Sol as the stronger sibling and Terra as the efficient one. Sol sits higher in the lineup: you pay double the per-token price, and in exchange you expect stronger reasoning, better judgment on hard problems, and higher reliability on tasks where a mistake is expensive. Terra is the model you reach for when the task is repetitive, high-volume, and cost-dominated — the thousand-invoices-a-day kind of work — where Sol's extra reasoning power would be wasted money.

OpenAI's own claim sharpens this: the company says Terra completes tasks 3x faster than Sol. If true, that would mean Terra is not just cheaper but quicker at getting agent jobs done — a double advantage for throughput workloads. But remember the attribution rule we are following throughout this article: OpenAI claims Terra is 3x faster than Sol at task completion; no independent test in our sources verifies this. Speed claims from vendors often reflect specific internal benchmarks, specific task types, and specific configurations. Your workload may differ.

How should a team actually choose between them? Use a simple rule of thumb. If the cost of a wrong answer is high — legal review, medical-adjacent work, financial decisions, anything where an error costs more than the tokens saved — favor the stronger model, Sol. If the task is routine, verifiable, and repeated thousands of times — data entry, invoice extraction, form filling, regression testing of software — Terra's half-price tokens are likely the rational choice, especially because you can afford to add verification steps (a second pass, a human spot-check) and still come out cheaper.

There is also a hybrid strategy many teams use: route easy cases to the cheap model and escalate hard ones. An agent can attempt a task with Terra, check its own confidence or have a lightweight verifier check the result, and kick the tricky 5% of cases up to Sol. You get Terra's economics on 95% of the volume and Sol's quality where it counts. This "model routing" pattern is one of the most practical ways to use a two-tier lineup, and Terra's launch makes the cheap tier cheaper.

One more consideration: the 1.05M-token context window. Both models are from the same generation, but the large context window is specifically notable for Terra because long agent sessions are its home turf. An agent that processes a 200-page contract, or works through a morning's worth of support tickets in one session, needs that memory. The window size is a verified spec, not a claim — 1.05 million tokens — and it is generous by any standard.

Terra vs Anthropic's Astra: The Cross-Company Fight

The more dramatic comparison is against Anthropic's Astra, because OpenAI is explicitly positioning Terra as an Astra competitor — and making aggressive claims about the matchup. OpenAI says Terra delivers roughly Astra-level quality at about one-tenth of Astra's per-token price, and completes tasks 3x faster. Both are OpenAI's claims, not independently verified results.

Let us unpack what "roughly Astra-level quality at a tenth of the price" would mean if it holds up. It would mean the price-performance frontier has moved: the level of capability that used to require a premium-priced model is now available at a budget price. For buyers, that is the difference between piloting an agent with a hundred tasks a day and running it on a hundred thousand. Entire categories of automation that were "technically possible but too expensive" would become economically viable overnight.

But the "if" is doing a lot of work in that paragraph, and an honest article has to stress-test the claim. Vendor benchmarks are chosen by the vendor. The tasks, the prompts, the number of retries allowed, the way "quality" is scored — all of these can tilt a comparison. "Roughly Astra-level quality" is also vague: quality at what tasks? Computer-use tasks, presumably, since that is Terra's specialty — but a model can be excellent at clicking through forms and mediocre at nuanced reasoning, and a single "quality" label hides that. Until independent evaluators run both models on the same tasks with the same scoring, the 10x price-performance claim is a hypothesis with a marketing department behind it.

There is also a strategic angle worth understanding. OpenAI and Anthropic are fighting over the enterprise agent market — the big contracts where companies automate real business processes. Price is a weapon in that fight. By launching Terra at half the price of its own previous models and claiming a tenth of Astra's price, OpenAI is trying to make cost the deciding factor in procurement discussions. Anthropic's likely response, based on how these cycles usually go, would be its own efficiency-tier model or a price cut. For buyers, competition is good news: even if you never use Terra, its existence puts downward pressure on the whole market's prices.

What should you actually do if you are choosing between Terra and Astra today? Three practical steps. First, define your task precisely — "process invoices" is not precise; "extract 12 fields from PDF invoices with 99%+ field accuracy" is. Second, run a head-to-head pilot on your own data with a few hundred real examples, scored by your own criteria, because your data is the only benchmark that matters for your decision. Third, price the full system, not just the tokens: engineering time, verification steps, error handling, and the cost of mistakes. A model that is 10x cheaper per token but needs twice the verification engineering may not be 10x cheaper in practice. The responsible position, given the evidence available on October 29, 2026: Terra's price is verified and attractive; its quality-versus-Astra claim is unverified and should be tested before you commit.

Head-to-Head: Pricing Comparison

Here are the numbers side by side. Only Terra's prices are directly verified; Sol and GPT-5.6 Terra prices are derived from OpenAI's stated 50% cut, and the Astra comparison reflects OpenAI's "one-tenth" claim. The table labels each figure's status so you can see exactly what is known and what is inferred.

Model	Input (per 1M tokens)	Output (per 1M tokens)	Cached input (per 1M)	Price basis
GPT-6.1 Terra	$1	$5	$0.05	Verified launch pricing
GPT-6.1 Sol	~$2	~$10	Not disclosed in our sources	Derived: Terra is a 50% cut vs Sol
GPT-5.6 Terra	~$2	~$10	Not disclosed in our sources	Derived: Terra is a 50% cut vs 5.6 Terra
Anthropic Astra	Not published in our sources; OpenAI claims Terra is ~1/10th the per-token price		Not disclosed in our sources	OpenAI's claim only — unverified

A few notes on reading this table. First, the "~" on Sol and 5.6 Terra matters: OpenAI said "50% price cut versus" those models, which arithmetically implies double Terra's price, but OpenAI did not publish the exact figures in the materials our sources cite — treat $2/$10 as the implied price, not a quoted one. Second, "per-token price" ratios can mislead when models use different tokenizers (different models split the same text into different numbers of tokens), so even the "one-tenth" claim is approximate by nature. Third, cached input at $0.05 is Terra's standout number: for agent workloads with heavy repeated context, the effective price per task can fall far below the headline $1 input rate. When comparing models for agent work, always model your own token mix — input vs output vs cached — rather than comparing headline rates alone.

To make the savings tangible, consider a mid-size operation running 50,000 agent tasks a month, each consuming 40,000 input tokens (half of it cacheable) and 4,000 output tokens. On Terra: input cost is 50,000 × 40,000 × $1/1M = $2,000 for fresh input, but with half cached at $0.05/1M the input bill drops to roughly $1,025; output is 50,000 × 4,000 × $5/1M = $1,000. Total: about $2,025 a month. At double the rates (the implied Sol pricing), the same workload is about $4,050. The 50% cut is real money at scale — roughly $24,000 a year in this example — which is why operations teams, not just developers, should be paying attention to this launch.

Head-to-Head: Use-Case Comparison

Price is only half the decision. The other half is fit: which model for which job? The quality and speed comparisons below are OpenAI's claims, clearly labeled — the use-case guidance is our editorial analysis of where a half-price agent model logically fits.

Use case	GPT-6.1 Terra	GPT-6.1 Sol	Anthropic Astra
High-volume form filling / data entry	Best fit: cheapest tokens, built for computer use	Overkill; paying 2x for unneeded reasoning	Capable but far pricier per OpenAI's claim
Invoice / document processing at scale	Best fit: named capability, huge context window	Use only for the hardest documents	Strong quality, but cost-prohibitive at volume
Automated software QA (clicking through apps)	Best fit: screen reading + acting, cheap retries	Reasonable for complex test logic	Viable alternative; verify price yourself
Video editing assistance	Promising (named capability); test before trusting	Better for creative judgment calls	Compare on your own footage
Complex reasoning / hard analysis	Not the pick; efficiency tier	Best fit within OpenAI's lineup	Strong contender; benchmark it
Long documents (100s of pages)	Best fit: 1.05M context at half price	Fine, but you pay double per token	Check its context limits and price
Prototyping / experimentation	Best fit: cheap iteration, cheap failures	Switch to Sol once the design is proven	Expensive way to experiment
Customer-facing chat quality	Adequate for simple flows; test tone	Best fit: stronger language quality	Known for strong conversational quality

The pattern in the table is deliberate: Terra wins where volume is high, tasks are repetitive, and mistakes are cheap to catch; Sol and Astra win where reasoning depth or output quality is the bottleneck. Most real deployments will use more than one model. The skill of 2026-era AI engineering is increasingly about routing — sending each task to the cheapest model that can handle it — and Terra gives architects a compelling new bottom tier to route to.

Who Should Use GPT-6.1 Terra

Terra is not for everyone, but for the right user it is close to a no-brainer. The ideal Terra user runs high-volume, repeatable computer-use work where token cost is the binding constraint. Let us name those users concretely.

Operations teams drowning in paperwork. If your business processes invoices, insurance claims, loan applications, customs forms, or HR onboarding packets — any flow where humans copy data between systems — Terra is built for exactly this. The economics are straightforward: take your monthly document volume, estimate tokens per document, and compare the model bill to the labor cost. At $1/$5 per million tokens, the model usually wins by orders of magnitude, and the 1.05M-token context window means even messy, long documents fit.

Developers building agents. If you are building with the OpenAI API (model ID gpt-6.1-terra), Terra lowers the cost of every experiment. Agent development is iteration-heavy: you run hundreds of test episodes while tuning prompts and tools. Cheap tokens mean more iterations for the same budget, which usually means a better final agent. Terra is also the right default for the "worker" role in multi-agent systems, where a planner model breaks work down and Terra executes the repetitive steps.

Startups and indie hackers. When you have no funding, every dollar of API spend is a dollar of runway. A model at half the price of the previous generation extends what a small team can ship: a solo founder can now afford to run an agent that monitors competitor prices, processes user signups, or triages support tickets around the clock. Terra's availability in ChatGPT Work (Plus tier and up) also means non-technical founders can use it without writing code.

QA and testing teams. Automated testing of software by actually clicking through it — "does the checkout flow still work after this update?" — is a natural computer-use workload. Tests run constantly, they are repetitive, and a failed test just gets re-run. Terra's claimed speed advantage (3x faster task completion, per OpenAI) would be especially valuable here if verified, because test suites are judged on wall-clock time.

Enterprises on AWS. The same-day AWS Bedrock launch is a direct invitation to corporate IT: use Terra inside your existing AWS accounts, with your existing security reviews, compliance paperwork, and consolidated billing. For regulated industries that cannot send data to every API on the internet, Bedrock availability can be the difference between "interesting" and "deployable." If you are an enterprise buyer, Terra's day-one Bedrock availability removes one of the biggest adoption blockers.

Who Should Not Use GPT-6.1 Terra

Honesty requires the other side of the ledger. Terra is an efficiency-tier model, and there are jobs where efficiency is the wrong thing to optimize.

Anyone who needs maximum reasoning quality. If you are doing strategic analysis, complex legal reasoning, advanced coding architecture, or scientific work where the best possible answer matters more than the cost of getting it, Terra is not positioned as the top-tier model. That is Sol's job in OpenAI's lineup, or Astra's in Anthropic's. Saving 50% on tokens is a bad trade if the answer is 10% worse on a decision worth millions.

Teams that need verified benchmarks before spending. As of this writing — three days after launch — the headline quality and speed claims (Astra-level quality at a tenth of the price, 3x faster than Astra/Sol) are OpenAI's assertions, reported by the press, not independent evaluations. If your procurement process requires third-party validation, wait for it. Independent benchmarks typically appear within weeks of a launch; making a large commitment before they do is gambling, not engineering.

Workflows where agents are the wrong tool. This is the most common mistake in 2026: using a computer-use agent where a direct integration would be better. If the software you need to automate has a proper API, use the API — it is faster, more reliable, and cheaper than any model clicking through screens. Agents are for the long tail of software with no API. Before reaching for Terra, ask: "Is there an API, a CSV export, or a database I could use instead?" If yes, do that first.

High-stakes actions without human oversight. An agent that can click anything can click the wrong thing: deleting records, sending emails, moving money. Terra's low price makes it tempting to automate aggressively, but price does not change the risk profile of unsupervised action. For irreversible actions — payments, deletions, external communications — keep a human approval step in the loop regardless of which model you use. Cheap tokens should never be an excuse for skipping oversight on irreversible actions.

Anyone expecting a finished product. Terra is a model, not an application. Using it for computer use means building or buying agent software around it: the harness that takes screenshots, the action layer that clicks, the verification that checks results. ChatGPT Work and Codex provide some of this out of the box, but serious deployments need engineering. If you want "upload invoices, get spreadsheet" with zero setup, you want a product built on Terra, not Terra itself.

Getting Started with GPT-6.1 Terra: A Practical Guide

You do not need to be a machine-learning expert to start using Terra. The fastest path depends on who you are: a ChatGPT subscriber, a developer, or an enterprise team — and each path is live today.

Path 1: ChatGPT Work or Codex (no code). If you are on ChatGPT Plus, Pro, Enterprise, or Edu, Terra is available inside ChatGPT Work and Codex. Start with a small, well-defined task: "read the invoices in this folder and extract the supplier, date, and total into a table." Watch what the agent does, step by step. The beginner mistake is handing the agent a vague, sprawling job on day one ("automate my accounting"). The professional approach is to start narrow, verify the output carefully, and widen the scope only after the narrow task works reliably. Keep a log of failures — which screens confused it, where it clicked wrong — because that log becomes your specification for guardrails.

Path 2: The API (developers). Call the model with the ID gpt-6.1-terra through the OpenAI API. If you are new to the API, the essential concepts are: you send a request containing your input (prompt, images, documents) and get back the model's output; you are billed per token as described above; and you can enable prompt caching to cut input costs on repeated context. For computer-use work specifically, you will also need an agent framework — software that captures screenshots, translates the model's decisions into mouse and keyboard actions, and feeds results back. OpenAI's own tooling and the open-source agent ecosystem both support this pattern; the model is the brain, the framework is the body. Budget for a pilot: run 200–500 real tasks, measure accuracy and cost per task, and only then decide on production.

Path 3: AWS Bedrock (enterprise). If your company standardizes on AWS, access Terra through Bedrock in your own account. The advantage is governance: data stays within your cloud boundary, access is controlled by your IAM policies, and spend shows up on your AWS bill. Talk to your cloud team about enabling the model in Bedrock, then run the same kind of pilot — a single well-defined workflow, measured on accuracy and cost — before expanding. Enterprises should also review the Bedrock-specific terms: data handling, region availability, and whether the model is covered by your existing AI governance approvals.

Five practical rules for your first agent project, whatever the path:

• Define "done" precisely. "Process invoices" is not a spec. "Extract these 12 fields with dates in YYYY-MM-DD format, flag any invoice over $10,000 for human review" is a spec. Agents fail most often on vague instructions.
• Build verification in from day one. A second, cheap check — a different prompt re-reading the extracted data, or a simple rule like "totals must match line items" — catches most errors. Verification is cheap; mistakes are expensive.
• Measure cost per completed task, not per token. Tokens are the unit you buy; completed tasks are the unit you care about. A model that uses twice the tokens but finishes without retries can be cheaper per task. Track both.
• Start with read-only or reversible actions. Let the agent read, extract, and draft before you let it submit, send, or delete. Add write permissions only after the read-only version is reliable.
• Use caching deliberately. Structure your prompts so the repeated parts (instructions, reference data) are stable and cacheable — that is how you capture the $0.05 cached-input rate instead of paying $1 for fresh input every step.

A note on expectations: your first agent will be slower and clumsier than you hope. That is normal. The teams getting value from computer-use agents in 2026 are the ones that treated the first month as paid learning — measuring, tightening specs, adding checks — not the ones that expected magic on day one. Terra's low price makes that learning phase cheaper, which may be its most underrated benefit: affordable experimentation.

Limits, Risks, and Honest Caveats

Every technology article should say what could go wrong, and agent models have a specific risk profile worth stating plainly. The core caveat: Terra's most impressive claims are unverified, and computer-use agents as a category are powerful but fallible.

Unverified vendor claims. To repeat the central attribution one more time, because it matters: "3x faster task completion than Astra/Sol" and "roughly Astra-level quality at one-tenth the per-token price" are OpenAI's claims. They were reported by SiliconANGLE, PYMNTS, modeldex, and atomic.chat as OpenAI's statements, not as independent findings. No third-party benchmark available to us at publication time confirms or refutes them. We will update this article when independent evaluations appear — and if they contradict OpenAI's claims, we will say so.

Agents make mistakes that look confident. A computer-use agent does not hesitate or ask for help the way a careful employee would; it acts, and its actions can be wrong in ways that are hard to spot at a glance — the right data in the wrong row, a click on a similarly-named button, a form submitted one screen too early. This is true of every agent model, not just Terra. The mitigation is verification and human-in-the-loop design for anything consequential, as discussed above.

Security and prompt injection. An agent that reads screens and web pages can be tricked by malicious content: a hidden instruction in a document, a misleading button label, a phishing page. This class of attack — prompt injection — is the central security problem of agentic AI. If your agent processes untrusted documents or browses the open web, assume adversarial content will eventually appear and design accordingly: restrict the agent's permissions, sandbox its environment, and never let it act on instructions found in untrusted content.

Price is not total cost. Terra's tokens are cheap, but a production agent system includes engineering time, infrastructure, monitoring, verification, error handling, and the human oversight we keep recommending. For simple workloads the token bill dominates and Terra shines. For complex deployments, the surrounding costs can dwarf the model bill — in which case the price difference between models matters less than reliability. Always budget the system, not just the tokens.

Launch-week uncertainty. This article was written three days after launch. Details can change: rate limits, exact availability per tier, Bedrock region coverage, and pricing nuances often get clarified in the weeks after announcement. Treat launch-week reporting — including this article — as a snapshot, and check OpenAI's current documentation before making commitments.

The Bigger Picture: Why a Half-Price Model Matters

Step back from the spec sheet and the bigger story comes into focus. GPT-6.1 Terra is evidence that the AI industry's battleground is shifting from raw intelligence to the economics of agency. For two years the headline race was "which model is smartest." Terra's headline is "which model is cheapest per completed task" — a different contest, and arguably the one that decides what actually gets deployed.

History suggests price cuts like this unlock new categories of use. When cloud computing got cheap, startups stopped buying servers and entire industries moved to the cloud. When Terra-class pricing makes agents affordable, the equivalent shift is businesses automating the long tail of software work that was never worth integrating: the niche industry app with no API, the government portal that only works in a browser, the supplier's ancient ordering system. Each one is small; together they are an enormous amount of human busywork.

There is also a competitive dynamic to watch. OpenAI has now put a public price anchor at $1/$5 for an agentic model with a million-token context. Anthropic, Google, and the open-weight ecosystem will have to respond — with their own efficiency tiers, price cuts, or superior quality at the premium end. For buyers, the winning move is to stay flexible: build your agent systems so the model is swappable, benchmark regularly, and let the vendors compete for your workload. The best thing about a price war is that you do not have to pick a side — you just have to be ready to switch.

Finally, a word on what this means for workers. Computer-use agents automate exactly the kind of repetitive screen work that fills many office jobs: copying data, filling forms, processing documents. That is genuinely disruptive for roles built around those tasks, and it is worth saying plainly rather than hiding behind euphemisms. The constructive response — for individuals and for companies — is to move human effort toward the things agents do poorly: judgment, relationships, exceptions, and oversight of the agents themselves. Terra makes the automation cheaper; it does not make the human judgment less valuable. If anything, cheap agents make good oversight more valuable, because someone has to be accountable for what the fleet of delivery vans does all day.

Frequently Asked Questions

What is GPT-6.1 Terra?
GPT-6.1 Terra is OpenAI's efficiency-focused AI model launched on October 26, 2026, built for "computer use" — operating software by reading screens and taking actions like a person would. It costs $1 per million input tokens and $5 per million output tokens via the API (model ID gpt-6.1-terra), which OpenAI positions as half the price of GPT-5.6 Terra and GPT-6.1 Sol.

What does "computer use" mean?
It means the AI can see what is on your screen, understand the interface — buttons, forms, menus — and operate it: clicking, typing, scrolling, and reading results. Practical examples OpenAI names include filling in forms, processing invoices, and editing video. It is designed for software that has no API, where the only way to automate is to drive the interface like a human.

How much does GPT-6.1 Terra cost?
Via the OpenAI API: $1 per million input tokens, $5 per million output tokens, and $0.05 per million cached input tokens. As a rough illustration, processing one invoice consuming 50,000 input and 5,000 output tokens would cost under ten cents in model fees. Your actual cost depends on your token mix — measure cost per completed task, not just per token.

Is GPT-6.1 Terra really as good as Astra at one-tenth the price?
That is OpenAI's claim, not an independently verified fact. OpenAI says Terra delivers roughly Astra-level quality at about one-tenth the per-token price and completes tasks 3x faster than Astra or Sol. No independent benchmark available at publication time (October 29, 2026) confirms this. Run your own pilot on your own data before making decisions based on the claim.

Should I choose Terra or GPT-6.1 Sol?
Choose Terra for high-volume, repetitive agent work where cost dominates — data entry, invoice processing, form filling, automated QA. Choose Sol when reasoning quality matters more than price — complex analysis, hard decisions, high-stakes outputs. Many teams use both: Terra for the bulk of routine work, Sol for the difficult cases.

Where can I access GPT-6.1 Terra?
In ChatGPT Work and Codex for Plus, Pro, Enterprise, and Edu tiers; through the OpenAI API as gpt-6.1-terra; and on AWS Bedrock, where it launched the same day as the announcement. Enterprise teams on AWS can use it inside their existing cloud accounts with standard governance controls.

What is the context window?
1.05 million tokens — roughly 750,000 English words. That is enough to hold very long documents, large codebases, or extended agent sessions with many screenshots and steps in the model's working memory at once, which is particularly useful for long multi-step computer-use tasks.

Is it safe to let an AI agent control my computer?
It carries real risks: agents can click the wrong thing, be tricked by malicious content in documents or web pages (prompt injection), and act confidently when wrong. Best practices: start with read-only tasks, add verification checks, keep humans approving irreversible actions (payments, deletions, external messages), restrict the agent's permissions, and never let it follow instructions found in untrusted content.

How We Verified This Article

• Launch date (October 26, 2026), pricing ($1 input / $5 output per 1M tokens; $0.05 cached input), 1.05M-token context window, computer-use capabilities, availability (ChatGPT Work, Codex; Plus, Pro, Enterprise, Edu), API model ID (gpt-6.1-terra), same-day AWS Bedrock launch: reported across SiliconANGLE (Oct 26, 2026), PYMNTS (Oct 26, 2026), modeldex (Oct 26, 2026), and atomic.chat (Oct 27, 2026).
• 50% price cut versus GPT-5.6 Terra and GPT-6.1 Sol: OpenAI's positioning as reported by the launch coverage; Sol/5.6 Terra dollar figures in our comparison table are derived arithmetically from this claim, not separately quoted.
• "3x faster task completion than Astra/Sol" and "roughly Astra-level quality at 1/10th the per-token price": OpenAI's vendor claims as reported in launch coverage — explicitly labeled as claims throughout this article, not independently verified.
• Explanatory content (what tokens are, how caching works, agent best practices, security risks): general technical knowledge, not vendor facts; no specific numbers invented.
• What we did not verify: independent benchmark results for Terra vs Astra or Sol (none available at publication); exact Sol/5.6 Terra list prices; per-tier rate limits and Bedrock region coverage.

Sources

• SiliconANGLE — OpenAI launches GPT-6.1 Terra (Oct 26, 2026)
• PYMNTS — OpenAI GPT-6.1 Terra coverage (Oct 26, 2026)
• modeldex — GPT-6.1 Terra launch details (Oct 26, 2026)
• atomic.chat — GPT-6.1 Terra analysis (Oct 27, 2026)

The Bottom Line

GPT-6.1 Terra is a straightforward proposition wrapped in aggressive marketing. The verified facts: launched October 26, 2026; $1/$5 per million tokens with $0.05 cached input; 1.05M-token context window; built for computer use; available in ChatGPT Work, Codex, the API as gpt-6.1-terra, and AWS Bedrock; priced at half of GPT-5.6 Terra and GPT-6.1 Sol. Those facts alone make it one of the most economically significant AI launches of the year for anyone running agents at scale.

The claims — 3x faster than Astra/Sol, Astra-level quality at a tenth of the price — are exciting and, for now, unproven. Treat them as OpenAI's opening bid in a price war, not as established truth. The right response is not skepticism or hype but measurement: pilot Terra on your own workload, score it on your own criteria, and let your data decide.

If the claims hold up even approximately, Terra changes who can afford serious automation — from well-funded enterprises to solo founders and small operations teams. And even if they only half hold up, a verified 50% price cut on a capable agentic model with a million-token context window is still a genuine shift in the economics of AI. In a market that spent two years asking "how smart can it get," OpenAI just asked a better question: "how cheap can useful get?" The industry's answer, over the next few months of independent testing and competitive response, will be worth watching.