OpenAI 又来开始卷价格了。
GPT-6.1 Terra 的标准 API 价格是每百万输入 token 1 美元，输出 5 美元，比上一代低 50%。但便宜的单价不等于便宜的已完成任务。选模型时应该比较每个验收通过任务的成本，也就是模型费用加人工补救，再除以通过验收的任务数。通过率低、重试多的低价模型，总账完全可能更贵。
Terra 发布后，价格成了讨论的焦点。价格腰斩耶，那是不是说以后写代码、修Bug的价格也能腰斩？这篇文章将用例子告诉你，事实是怎么样的。
GPT-6.1 Terra 是什么模型
GPT-6.1 Terra 是 OpenAI 推出的快速、高效模型，定位是兼顾视觉推理、计算机操作和写作表现。它是 GPT-5.6 Terra 的升级版本，面向日常工作中的沟通和计算机任务，例如起草提案、解读技术图纸、填写表单和剪辑视频。
官方的定位是在速度、能力和成本之间取得新的平衡。公告举的典型场景是大批量自动化，比如读取收到的发票，再把详细信息录入会计软件。
价格与可用渠道
API 调用名是 gpt-6.1-terra。标准 API 定价为每百万输入 token 1 美元，每百万缓存输入 token 0.05 美元，每百万输出 token 5 美元。标准 API 价格比 GPT-5.6 Terra 和 GPT-6.1 Sol 低 50%。
Plus、Pro、Enterprise、Edu 用户可以在 ChatGPT 工作和 Codex 中使用，开发者可以通过 OpenAI API 调用。官方还提到，在 ChatGPT 工作和 Codex 中，相同的使用额度能完成的任务，比 GPT-5.6 Terra 更多。
能力表现
以下都是 OpenAI 公布的基准数据。
- 计算机操作： 在 Agents' Last Exam 上，中等推理强度下的得分比 GPT-5.6 Terra 高 15 个百分点，成本约为后者的三分之一。在 OSWorld 2.1 上，中等推理强度就超过了 GPT-5.6 Terra 的最佳成绩。
- 视觉推理： 在 MMMU-Pro 上，所有推理设置下都优于 GPT-5.6 Terra。
- 事实准确性： 在 OpenAI 内部由易诱发错误的提示词构成的测试中，低推理强度下的错误率从 53.6% 降到 16.7%，最高推理强度下降到 4.3%。
- 软件工程 ： 在测试命令行编程能力的 Terminal-Bench 4.0 上，最高推理强度下解决了 50.3% 的任务，GPT-5.6 Terra 已公布的成绩是 21.5%。
- 速度： 完成任务的速度是 GPT-6 Astra 和 GPT-6.1 Sol 的三倍以上。
官方同时说明，对于最复杂的编程任务，GPT-6.1 Sol 和 GPT-6 Astra 仍然是更好的选择。这一条边界，是后文任务选择规则的依据。
安全与对齐
官方表示，Terra 的网络安全能力达到了准备框架规定的 Critical 级别阈值，并保留了为 GPT-6 Astra 开发的防护措施。在对齐评估中，Terra 比 GPT-5.6 Terra 更可能在任务范围内行事，并如实说明自身局限。在提示词注入测试中，它对恶意指令也表现出较强的抵抗力。详细内容见官方系统卡。
十分之一和九分之一，分别比的是什么
传播中最常见的说法是十分之一，公告里有两处接近的表述，对比对象不同。
第一处，在 Agents' Last Exam 上，Terra 的表现可与 GPT-6 Astra 相媲美，而每个 token 的价格仅为后者的十分之一。比较的是 token 单价，对象是 Astra，任务是计算机操作。
第二处，在最高推理强度下，Terra 的 token 使用效率是 Claude Opus 5.5 的三倍以上，每个 token 的价格为后者的四分之一，所以每项任务的成本约为后者的九分之一。
这两处都不是修一个 bug 能便宜到十分之一的意思。第二处已经改用每项任务成本的口径，说明官方自己也没有把单价等同于总成本。
单价低为什么不等于总账低
只比较每百万 token 的单价，会漏掉三项成本。
- 一个任务通常不止一次尝试。 第一次修复没过测试，就要带着报错再来一轮，每多一轮，输入和输出都要重新计费。
- 失败的尝试同样计费。 补丁写错了，token 已经消耗，费用不会退回。
- 失败后需要人来收尾。 工程师花 15 分钟排查模型改坏的地方，成本可能高于几十次 API 调用。
所以低单价只是必要条件。通过率明显更低的便宜模型，总成本可能更高。通过率相当时，低单价才会实实在在转化为省钱。
另外，一些公开讨论里会用单个案例证明便宜模型更划算，比如几分钟、一两美元完成一个小游戏。这类案例很直观，但缺少统一的验收标准，没有交代成品是否通过测试、是否需要返工，很难折算成每个验收通过任务的成本。本文引用的转述案例未经核实，只作为说明问题的背景。
账单由哪几部分构成
按官方费率，一次调用的费用由三部分相加。
输入是代码文件、报错日志和提示词，按每百万 token 1 美元计费。缓存输入是多轮重试中重复出现的上下文，按每百万 token 0.05 美元计费，只有普通输入的二十分之一。输出是补丁、解释和推理产生的内容，按每百万 token 5 美元计费，是输入单价的 5 倍。
重试场景里，缓存的作用尤其明显。代码文件和历史上下文在多轮中反复出现，命中缓存后，每多一轮的边际成本会明显下降。但缓存能否命中取决于前缀是否一致等条件，具体规则和有效时长以官方文档为准。设计提示词时，把项目说明、文件内容这类固定部分放在前面，把本轮报错这类变动部分放在后面，更容易命中缓存。
输出价格较高，所以推理强度调高后，单次费用会随输出增加而上升。
从单价到总账的五步推演
- 单价： 查官方费率，区分输入、缓存输入、输出。
- 尝试次数： 记录每个任务实际用了几轮，每轮消耗多少 token。
- 验收： 事先写好通过标准，包括指定测试全部通过、原有测试不退化、不允许改测试文件。
- 人工补救： 记录模型失败后人工介入的分钟数，按统一时薪折算。
- 总账 ： 套用下面的公式。
每个验收通过任务的成本 = (模型费用总和 + 人工补救成本) / 验收通过任务数
这里的验收通过包含人工补救后通过的任务，否则公式会漏掉失败的代价。想单独看模型本身的表现，可以另外统计未经人工直接通过的比例。
计算示例：单价低一半，总账高十几倍
下面是计算示例，参数全部为假设，不代表 Terra 或任何模型的真实通过率。
假设条件如下。
- 每次尝试消耗未缓存输入 1 万 token、缓存输入 3 万 token、输出 8000 token。
- 每个任务最多尝试 3 次，通过即停止。
- 3 次都失败时，人工补救 15 分钟，按每小时 60 美元折算，即 15 美元。
- 模型 A 使用 Terra 费率，单次通过率设为 40%。
- 模型 B 单价为 Terra 的 2 倍，单次通过率设为 80%。
按 Terra 费率，单次尝试的费用为输入 0.01 美元、缓存输入 0.0015 美元、输出 0.04 美元，合计 0.0515 美元。
下面的 Python 代码可以复现全部数字。
def cost_per_accepted_task(p， price_mult， cap=3， manual_fix=15.0)：
# 单次尝试费用(美元)，费率为示例中的 Terra 标准费率
per_attempt = (10_000 * 1 + 30_000 * 0.05 + 8_000 * 5) / 1_000_000 * price_mult
fail_all = (1 - p) ** cap # 全部尝试都失败的概率
expected_attempts = sum((1 - p) ** i for i in range(cap)) # 期望尝试次数
model_cost = expected_attempts * per_attempt
manual_cost = fail_all * manual_fix # 失败后的人工补救期望成本
return per_attempt， expected_attempts， fail_all， model_cost， manual_cost， model_cost + manual_cost
print(cost_per_accepted_task(0.4， 1)) # 模型 A：Terra 费率
print(cost_per_accepted_task(0.8， 2)) # 模型 B：2 倍单价
计算结果如下。
在这组假设下，单价低一半的模型 A，总成本约为模型 B 的 13 倍，人工补救占了大头。只看模型费用，A 每个任务 0.101 美元，B 是 0.128 美元，A 反而略便宜。
反过来也成立。A 的通过率提高到接近 B，人工补救成本会迅速缩小，价格优势才会体现出来。所以关键不在单价，在通过率，以及失败后要花多少人力。
如何设计可复现的实验
想在自己的项目里验证，可以按下面的方式设计。
- 任务选择。 选一个能稳定复现的 bug，附带会失败的测试用例，公开仓库和对应的 commit。难度取中等，既不能一次就过，也不能完全无解。
- 验收标准。 指定测试全部通过，原有测试不退化，不允许通过修改测试文件达成通过。
- 控制变量。 使用同一份提示词、同一个代码快照、同一个重试上限。计费渠道也要一致，API 和订阅套餐的数字不要混在一起。每个模型需要多跑几次，单次结果受随机性影响较大。
- 记录字段。 建议每次尝试记录以下内容，token 数可以直接取自 API 返回的用量字段。
选模型的任务规则
官方也提出了，最复杂的编程任务仍建议使用 GPT-6.1 Sol 或 GPT-6 Astra。结合前面的账本思路,可以先做一个初步分配,再用自己的数据修正。
范围明确、有测试覆盖的小修复,可以优先试 Terra。这类任务通过率通常较高,重试少,低单价的优势更容易体现出来。批量、重复性高的处理任务也适合先用 Terra,总量一大,单价的差异会被放大。
跨模块的重构,或者依赖关系复杂的改动,建议先评估更强的模型。这类任务一旦失败,人工补救的成本很高,单次调用省下的那点钱不够填。
需求不清晰、缺少测试的任务,先补测试再选模型。没有验收标准,就没法算每个验收通过任务的成本,选哪个模型都只是凭感觉。
这套分法只是起点。更可靠的依据是自己的任务数据。先跑一批任务,算出每个验收通过任务的成本,再决定哪类任务交给哪个模型。
用 ServBay 固定验收环境
做成本对比时,环境差异会干扰结果。同一个 bug,换了语言版本或数据库版本,测试结果可能就不同。模型第一次失败,有时是代码写错了,有时只是依赖版本不一致,两种失败不应该混在一起计算。
ServBay 可以在本机固定 PHP、Node.js、Python 等语言版本,也能固定数据库和站点配置。验收环境固定后,各模型的每次尝试都在同一个条件下运行,尝试次数和通过率才有可比性。
而且 ServBay AI Gateway 适合作为本机统一入口，虚拟密钥调用，真密钥留在网关侧；用量、费用、延迟能汇总看，也能把 Claude Code、Codex 等切到同一本地入口。OpenAI / Anthropic / Gemini 兼容协议都有对应路径。
总结
Terra 把价格、速度和编程能力同时往前推了一步，这点从官方数据看是清楚的。但官方数据来自特定基准，自己的任务能不能省钱，要用自己的验收标准来回答。
模型竞争正在从比跑分转向比完成一项任务要花多少钱、多少时间、能否稳定交付。对开发者来说，更实用的做法是先拿一个可复现的 bug，记录每次尝试的 token 和人工时间，算出每个验收通过任务的成本，再决定选哪个模型。
本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。
Open AI is back to roll prices.
The standard API price for GT-6.1 Terra is $1 per million input token and $5 for output, 50 per cent lower than the previous generation. But cheap unit prices are not equal to cheap completed tasks. The model should be selected by comparing the cost of each acceptance check mission, i.e. model cost plus manual remediation, divided by the number of missions through acceptance check. Through a low-cost model with low rates and more than retry, the general ledger may well be more expensive.
After Terra publish, prices became the focus of discussions. The price is flat, isn't it? This article will give you examples of what the truth is.
What model is GPT-61 Terra?
GPT-6.1 Terra is a fast and efficient model launched by Open AI, positioning against visual reasoning, computer operations and writing performance. It is an upgraded version of GPT-5.6 Terra and is oriented towards communication and computer tasks in daily work, such as drafting proposals, reading technical drawings, filling in forms and editing videos.
Official positioning is a new balance between speed, capacity and cost. The typical scenario presented in the bulletin is a massive automation, such as reading invoices received and entering detailed information into the accounting software.
Prices and available channels
The API call is gpt-61-terra. Standard API pricing is $1 per million input token, $0.05 per million cache input token 0.05 per million output token 5. Standard API prices are 50% lower than GPT-5.6 Terra and GPT-6.1 Sol.
Plus, Pro, Enterprise, and Edu users can be used in ChatGPT jobs and Codex, and developers can call through Open AI API. The official also mentioned that in ChatGPT jobs and Codex, the same use of quota could accomplish more tasks than GPT-5.6 Terra.
Capacity performance
Below are all the baseline data published by Open AI.
- Computer operations: On Ages' Last Exam, the median reasoning strength scored 15 percentage points higher than GPT-5.6 Terra, at a cost of about one third of the latter. In OSWorld 2.1, the moderate reasoning strength exceeded GPT-5.6 Terra ' s best performance.
- Visual reasoning: On MMMU-Pro, all reasoning settings are better than GPT-5.6 Terra.
- Factual accuracy: In the tests within Open AI, consisting of prompt, which is prone to error, the error rate under the low degree of reasoning fell from 53.6 per cent to 16.7 per cent and the highest level of reasoning fell to 4.3 per cent.
- Software engineering: In Terminal-Bench 4.0, which tested command line programming capabilities, 50.3 per cent of the tasks were resolved with the highest degree of reasoning, and GPT-5.6 Terra had published an achievement of 21.5 per cent.
- Speed: The speed of mission completion is more than three times that of GPT-6 Astra and GPT-6.1 Sol.
Officially, at the same time, GPT-61 Sol and GPT-6 Astra remain the best options for the most complex programming tasks. This boundary is the basis for the later selection rules.
Security and alignment
Officially, Terra ' s network security capability meets the level-Critical threshold set out in the preparation framework and retains the protective measures developed for GPT-6 Astra. In the alignment assessment, Terra is more likely than GPT-5.6 Terra to act within its mandate and to be realistic about its limitations. In the prompt injection test, it also showed greater resistance to malicious orders. Details can be found in the official system card.
One in ten and one in nine.
The most common expression in the dissemination is one tenth, with two close expressions in the bulletin, with different objects of comparison.
First, on the Ages' Last Exam, Terra's performance is comparable to that of GPT-6 Astra, and each token price is only one tenth of the latter. The comparison is token unit price for Astra, which is computer-operated.
Second, at the highest level of reasoning, Terra ' s token efficiency is more than three times that of Claude Opus 5.5, at a price of one quarter per token, so the cost of each task is about one ninth of the latter.
Neither of them meant to fix a bug to a tenth. The second has been converted to the calibre of the cost per mission, which means that the official itself has not equated the unit price with the total cost.
Why isn't a low unit price equal to a low general ledger?
Only three costs per million token unit are missed.
- A mission usually tries more than once. Once the first repairs have not been tested, another round with errors will have to be recosted for each additional round.
- Failed attempts are equally expensed. The patch is wrong, Token has been consumed and the cost will not be returned.
- You need someone to finish after you fail. Engineers spend 15 minutes searching for damaged models at a cost that may be higher than dozens of API calls.
So low unit prices are only necessary. The total costs may be higher through cheaper models with significantly lower rates. When the pass rate is comparable, the low unit price translates into real savings.
In addition, individual cases are used in public discussions to prove that cheap models are more cost-effective, such as minutes, $1 or $2 for a small game. Such cases are intuitive, but there is no uniform acceptance criteria, and it is difficult to convert the completed product into the cost of a mission per acceptance check if it is tested and whether it needs to be returned to work. The recitation cited here is unverified and serves only as a background to the problem.
Which part of the bill?
At official rates, the cost of a single call is added by three components.
Inputs are code files, error logs and prompt at $1 per million token. cache input is context, which is repeated in multiple rounds of retry, at a cost of US$ 0.05 per million token, which is only one-tenth of the normal input. The output is the content generated by patches, explanations and reasoning at $5 per million token, which is five times the unit price entered.
The role of cache is particularly evident in the retry scene. Code documents and historical context appear repeatedly in multiple rounds, and after hitting cache, the marginal cost of each additional round will decline significantly. However, the success of cache depends on such conditions as consistency of prefixes, and the rules and duration of validity are based on official documents. When prompt is designed, fixed parts such as project description, document content are placed in front, and those changes such as misreporting in this round are placed in the back, making it easier to hit cache.
As output prices are higher, a higher degree of reasoning leads to an increase in single-time costs.
Five steps from unit to general.
- Unit price: Check official rates to distinguish between input, cache input and output.
- Number of attempts: Record how many rounds each mission actually used and how much token each round consumed.
- acceptance check: Prior writing of standards for passing, including the designation that all tests were passed, that the original tests were not degraded and that no changes to the test documents were allowed.
- Manual remediation: Recording of minutes of manual intervention following failure of the model, converted to a uniform hourly rate.
- General: Apply the formula below.
Cost per acceptance check mission = (total model cost + manual remediation cost) / acceptance check mission number
The acceptance check here passes through tasks that include manual remediation, otherwise the formula will miss the cost of failure. In order to look at the performance of the model itself alone, it is possible to calculate separately the percentages that are not directly passed by manual means.
Example of calculation: unit price is 50% lower and total bill is more than 10 times higher
The following is an example of calculation, the parameters being all hypothetical and not representative of the real pass rate of Terra or any model.
The assumptions are as follows.
- Ten thousand token, thirty thousand token, eight thousand token per attempt.
- Every mission tried up to three times, by then stopped.
- When three failed, manual remediation was 15 minutes at $60 per hour, or $15.
- Model A uses the Terra rate, with a single pass rate of 40 per cent.
- Model B has 2 times the unit price of Terra and a single pass rate of 80%.
At Terra rates, the cost of a single attempt is $0.01 for input, $0.0015 for cache input, $0.04 for output, totalling $0.0515.
The Python code below can reproduce all numbers.
def cost_per_accepted_task(p， price_mult， cap=3， manual_fix=15.0)：
# One-time trial fee (in United States dollars) at the standard Terra rate in the example
per_attempt = (10_000 * 1 + 30_000 * 0.05 + 8_000 * 5) / 1_000_000 * price_mult
Fail all = (1 - p) ** cap # Probability of all attempts to fail
# The expected number of attempts
model_cost = expected_attempts * per_attempt
Expected cost of manual remediation after failure
return per_attempt， expected_attempts， fail_all， model_cost， manual_cost， model_cost + manual_cost
# Model A: Terra Rate
# Model B:2 times unit price
The results are as follows.
Under this scenario, model A, with a unit price lower than half, would cost about 13 times more than model B, with manual remediation taking the bulk. Just look at model costs, A for each assignment, $ 0.101, B for 0.128, A for a little less.
The opposite is true. The pass rate of A has been raised to near B, and the cost of manual remediation will be reduced rapidly so that price advantages will be reflected. So it's not about the unit price, the pass rate, and how much manpower it takes to fail.
How to design replicable experiments
To be validated in your own project, it can be designed as follows.
- Task selection. Select a bug that can stabilize the recurrence, with a failed test example, an open warehouse and a corresponding commission. The difficulty is moderate and cannot be overcome at once or completely unsolved.
- acceptance criteria. All specified tests are passed and the original tests are not degraded and are not allowed to be passed by modification of the test document.
- Control variables. Use the same prompt, same code snapshot, same retry cap. And the billing channels are consistent, and API and the subscription package numbers are not mixed. Each model needs to run several times, and the single result is more randomly influenced.
- Record field. It is recommended that each attempt be made to record the following, the number of tokens can be taken directly from the amount field returned by API.
Task rules for selecting models
Officially, the most complex programming tasks still recommend the use of GPT-61 Sol or GPT-6 Astra. In conjunction with the previous line of account, a preliminary distribution could be made and then amended with its own data.
Clear scope, small repairs with test coverage, with Terra being given priority. The pass rate for such tasks is usually high, retry is low and the advantage of low unit prices is more readily felt. Batch, repetitive processing tasks are also suitable for first-time use in Terra, with a large volume, and differences in unit prices are magnified.
Cross-module re-engineering, or reliance on complex changes, is recommended to evaluate stronger models first. When such missions fail, the cost of manual remediation is high and the savings from single calls are insufficient.
The need is unclear, the task of testing is missing, and the test is followed by the model. Without acceptance criteria, it is not possible to calculate the cost of each acceptance check mission, and any model chosen is based on feelings.
The division is only the starting point. A more reliable basis is its own mission data. Run a group of tasks, calculate the cost of each acceptance check mission, and determine which type of mission is assigned to which model.
Fixed acceptance check environment with ServBay
When cost comparisons are made, environmental differences interfere with results. In the same bug, the results of the tests may be different if the language version or the database version is changed. The model failed for the first time, sometimes with the wrong code, sometimes with inconsistent versions, and the two failures should not be counted together.
ServBay can fix the PHP, Node.js, Python, etc. on this machine, as well as the database and site configuration. When the environment of acceptance check is fixed, each attempt of the model operates under the same conditions and the number of attempts and the pass rate are comparable.
Moreover, ServBay AI Gateway is suitable as a single portal, with a virtual key call and a real key left on the side of the gateway; usage, cost, delay can be aggregated and Claude Code, Codex, etc. can be cut to the same local entrance. Open AI / Anthropic / Gemini compatibility protocols have corresponding paths.
Summary
Terra moved the price, speed and programming capacity forward simultaneously, which is clear from official data. However, official data are drawn from specific benchmarks, and whether their own mission can save money and answer with their own acceptance criteria.
Model competition is shifting from running points to how much, how much time and whether it will take to complete a mission. For developers, it would be more practical to take a replicable bug, record the token and manual time of each attempt, calculate the cost of each acceptance check passing through the task and decide which model to choose.
Auto-fetched and translated by AI Atlas. All rights belong to the original author.