I Started With the Price, Then Did the Arithmetic
OpenAI cut the headline rate again. GPT-6.1 Terra's standard API price is $1 per million input tokens and $5 per million output tokens, about 50% lower than the previous generation.
My first reaction was the same as most people's. If the list price halves, does fixing a bug cost half as much?
No. A cheaper unit price does not make a cheaper completed task. I now compare models on cost per accepted task, which is model spend plus human cleanup, divided by the number of tasks that pass acceptance. A cheap model with a low pass rate and a lot of retries can still cost more overall. This post walks through the arithmetic I use and the numbers OpenAI published at launch.
What Terra Is
GPT-6.1 Terra is OpenAI's fast, efficient model. OpenAI positions it as a new balance of speed, capability, and cost. The announcement's typical scenario is high-volume automation, such as reading incoming invoices and entering details into accounting software.
What It Costs
The API model name is gpt-6.1-terra.
| Item | Price |
|---|---|
| Input | $1 per million tokens |
| Cached input | $0.05 per million tokens |
| Output | $5 per million tokens |
That standard API price is 50% lower than GPT-5.6 Terra and GPT-6.1 Sol.
Plus, Pro, Enterprise, and Edu users can use it in ChatGPT Work and Codex. Developers can call it through the OpenAI API. OpenAI also notes that with the same usage quota in ChatGPT Work and Codex, you can finish more tasks than with GPT-5.6 Terra.
The Benchmark Numbers, and What They Leave Out
Everything below is from OpenAI's published benchmarks.
Computer Use
On Agents' Last Exam at medium reasoning effort, scores are about 15 percentage points higher than GPT-5.6 Terra at roughly one-third the cost. On OSWorld 2.1, medium reasoning already beats GPT-5.6 Terra's best result.
Visual Reasoning
On MMMU-Pro, it beats GPT-5.6 Terra at every reasoning setting.
Factual Accuracy
On OpenAI's internal test built from prompts that tend to trigger errors, the error rate at low reasoning effort fell from 53.6% to 16.7%, and to 4.3% at maximum reasoning effort.
Software Engineering
On Terminal-Bench 4.0, the command-line coding benchmark, it solved 50.3% of tasks at maximum reasoning effort. GPT-5.6 Terra's published score was 21.5%.
Speed
Task completion is more than 3× faster than GPT-6 Astra and GPT-6.1 Sol.
The Boundary OpenAI Draws
OpenAI states that for the most complex coding work, GPT-6.1 Sol and GPT-6 Astra remain better choices. That sentence matters more than the leaderboard lines, because it sets the task-selection rule I use further down.
Safety Notes
OpenAI says Terra's cybersecurity capability reaches the Critical risk level in its Preparedness Framework, and it keeps the protections built for GPT-6 Astra. In alignment evaluations, Terra is more likely than GPT-5.6 Terra to stay within the task scope and to state its own limits accurately. In prompt-injection tests it also shows strong resistance to malicious instructions. Details are in the official system card.
The "One-Tenth" Claim Compares Two Different Things
The most common claim in circulation is one-tenth. The announcement has two nearby statements with different comparison targets.
The Astra Comparison
On Agents' Last Exam, Terra's performance is comparable to GPT-6 Astra while each token costs about one-tenth as much. That compares token unit price, against Astra, on computer-use tasks.
The Opus 5.5 Comparison
At maximum reasoning effort, Terra's token efficiency is more than 3× Claude Opus 5.5's, and each token costs about one-fourth as much, so cost per task is roughly one-ninth.
Neither claim says fixing one bug costs one-tenth as much. The second one already uses a per-task framing, and OpenAI itself does not equate unit price with total cost.
Three Costs the Price Per Million Hides
Comparing price per million tokens alone misses three things.
A Task Is Rarely One Attempt
If the first fix fails tests, the retry carries the error log with it. Every extra round bills input and output again.
Failed Attempts Still Bill
A wrong patch still spends tokens. That spend is not refunded.
Failures Need Human Cleanup
Fifteen minutes of engineer time debugging a bad model change can cost more than dozens of API calls.
So a low unit price is a necessary condition, not a sufficient one. A cheaper model with a clearly lower pass rate can still cost more overall. When pass rates are similar, the low unit price turns into real savings.
About the One-Dollar Demo Stories
Some public discussions use a single case to argue the cheaper model is the better deal, for example finishing a small game in a few minutes for a dollar or two. Those stories are vivid. Without a shared acceptance bar, and without saying whether the deliverable passed tests or needed rework, they are hard to convert into cost per accepted task. Case studies retold here were not independently verified, so I treat them as background only.
What Is Actually on the Bill
At the official rates, one call's cost is the sum of three parts.
Input and Cached Input
Input covers code files, error logs, and the prompt, billed at $1 per million tokens. Cached input is context that repeats across retries, billed at $0.05 per million tokens, one-twentieth of ordinary input.
Output
Output covers patches, explanations, and reasoning tokens, billed at $5 per million tokens, 5× the input unit price. Raising reasoning effort increases per-call cost as output grows.
Why Cache Matters Most on Retries
Code and prior context show up round after round. When cache hits, the marginal cost of another round drops sharply. Whether cache hits depends on prefix consistency and other conditions. The exact rules and TTL follow OpenAI's docs. When designing prompts, I put stable project notes and file contents first and this round's error text last, so cache is more likely to hit.
Five Steps from Unit Price to a Comparable Number
Step 1 to Step 4
- Unit price. Look up official rates for input, cached input, and output.
- Attempts. Record how many rounds each task took and how many tokens each round used.
- Acceptance. Write the pass criteria up front. Named tests all pass, no regression on existing tests, no editing test files to force a pass.
- Human cleanup. Record minutes of human intervention after model failure, converted at a single hourly rate.
Step 5 and the Formula
Cost per accepted task = (total model spend + human cleanup cost) / number of accepted tasks
Accepted here includes tasks that passed only after human cleanup. Otherwise the formula hides the cost of failure. To judge the model alone, also track the share that passed with no human help.
Worked Example: Half the Unit Price, 13× the Bill
This is a calculation example. All parameters are assumed. They do not represent real pass rates for Terra or any other model.
Assumptions
- Each attempt uses 10,000 uncached input tokens, 30,000 cached input tokens, and 8,000 output tokens.
- At most 3 attempts per task, stopping on success.
- If all 3 fail, human cleanup takes 15 minutes at $60/hour, which is $15.
- Model A uses Terra rates with a 40% per-attempt pass probability.
- Model B costs 2× Terra's unit price with an 80% per-attempt pass probability.
- At Terra rates, one attempt costs $0.01 input + $0.0015 cached + $0.04 output = $0.0515.
The Code
def cost_per_accepted_task(p, price_mult, cap=3, manual_fix=15.0):
# Per-attempt cost (USD) at the example Terra standard rates
per_attempt = (10_000 * 1 + 30_000 * 0.05 + 8_000 * 5) / 1_000_000 * price_mult
fail_all = (1 - p) ** cap # probability all attempts fail
expected_attempts = sum((1 - p) ** i for i in range(cap)) # expected number of attempts
model_cost = expected_attempts * per_attempt
manual_cost = fail_all * manual_fix # expected human cleanup after total failure
return per_attempt, expected_attempts, fail_all, model_cost, manual_cost, model_cost + manual_cost
print(cost_per_accepted_task(0.4, 1)) # Model A: Terra rates
print(cost_per_accepted_task(0.8, 2)) # Model B: 2× unit price
Results
| Item | Model A (1× price, 40% pass) | Model B (2× price, 80% pass) |
|---|---|---|
| Cost per attempt | $0.0515 | $0.103 |
| Expected attempts | 1.96 | 1.24 |
| Model spend | $0.101 | $0.128 |
| Probability all fail | 21.6% | 0.8% |
| Expected human cleanup | $3.24 | $0.12 |
| Cost per accepted task | ~$3.34 | ~$0.25 |
Reading the Table
Under these assumptions, Model A at half the unit price has about 13× Model B's total cost, and human cleanup dominates. Looking only at model spend, A is $0.101 per task and B is $0.128, so A is slightly cheaper. That single column is where a lot of the price debate stops.
The reverse also holds. If A's pass rate rises toward B's, human cleanup shrinks quickly and the price edge shows up. The hinge is not unit price. It is pass rate, plus how much human time a failure costs.
Running This on My Own Repo
Task Choice
Pick a stably reproducible bug with a failing test, a public repo, and a fixed commit. Medium difficulty works best, meaning not one-shot solvable and not hopeless.
Acceptance
Named tests all pass, no regression on existing tests, no editing test files to force a pass.
Controls
Same prompt, same code snapshot, same retry cap. Keep billing channels consistent, and do not mix API numbers with subscription quotas. Run each model several times, because a single run is noisy.
Fields to Record
Log the same fields each attempt and take token counts from the API usage fields, not from estimates. The table above is the shape I keep.
Where Terra Fits in My Task Split
OpenAI also says the most complex coding work still favors GPT-6.1 Sol or GPT-6 Astra. Combined with the ledger above, a rough split is a reasonable starting point, corrected later with your own data.
Start With Terra
Scoped fixes with test coverage are a good place to try Terra first. Pass rates are usually higher, retries fewer, and the low unit price shows up more clearly. High-volume, repetitive jobs also fit, because at scale the unit-price gap gets amplified.
Start With a Stronger Model
Cross-module refactors or tangled dependency changes are better evaluated on a stronger model first. When those fail, human cleanup is expensive, and the money saved on a single call will not cover it.
Fix the Tests First
If requirements are fuzzy and tests are missing, add tests before picking a model. Without acceptance criteria there is no way to compute cost per accepted task, and any model choice is a gut call.
Fixing the Acceptance Environment
When comparing cost, environment drift muddies results. The same bug can behave differently across language or database versions. A model's first failure might be bad code, or it might be mismatched dependencies. Those two failures should not sit in the same ledger.
Pinning the Runtime
ServBay, an AI development management tool I use for this, can pin PHP, Node.js, Python, and other runtimes on the same machine, along with database and site config. Once the acceptance environment is fixed, every model attempt runs under the same conditions, so attempt counts and pass rates become comparable.
One Endpoint for Model Calls
The ServBay AI Gateway also works as a single entry point. Calls go out with virtual keys while the real upstream keys stay encrypted and isolated from the project configs, and virtual keys can be revoked. Usage, cost, and latency roll up in one place, and Claude Code, Codex, and similar tools can point at the same endpoint. OpenAI, Anthropic, and Gemini compatible paths are available.
FAQ
Does a lower model unit price always save money?
Not necessarily. Unit price is only one part of total cost. With low pass rates, many retries, and heavy human cleanup, a cheap model can still cost more. The right metric is cost per accepted task.
How do you compute cost per accepted task?
Add total model spend to human cleanup cost, then divide by the number of accepted tasks. Model spend must include both successful and failed attempts.
What is GPT-6.1 Terra's API price?
Per the launch announcement, standard API pricing is $1 per million input tokens, $0.05 per million cached input tokens, and $5 per million output tokens. Prices can change, so use OpenAI's official pricing page.
Is Terra a fit for complex coding tasks?
On Terminal-Bench 4.0 at maximum reasoning effort, Terra solved 50.3% of tasks, a clear jump over the previous generation. OpenAI also says the most complex coding work is still a better fit for GPT-6.1 Sol and GPT-6 Astra.
Can cache hits distort a cost comparison?
Yes. Tasks with high cache hit rates cost less than estimates that assume ordinary input prices. In comparison runs, record each model's cached token counts and keep prompt structure consistent.
Is Copilot billed the same as the API?
No. The launch announcement does not spell out Copilot billing, so check GitHub's official billing docs. Do not apply API token unit prices directly.
What I Am Changing
Terra pushes price, speed, and coding ability forward together, and OpenAI's numbers make that clear. Those numbers come from specific benchmarks. Whether a given codebase gets cheaper still depends on its acceptance criteria.
The comparison is shifting away from leaderboard scores and toward how much money and time one finished task takes, and whether delivery stays reliable. The practical move is small. Take one reproducible bug, log tokens and human minutes per attempt, compute cost per accepted task, and then pick the model. Most of that judgment does not need a model to make it.
Top comments (0)