GPT-6.1 Terra: pricing and the routing decision

OpenAI released GPT-6.1 Terra on October 26, 2026. In its official announcement, accessed October 28, the company reports parity with GPT-6 Astra on Agents’ Last Exam when GPT-6.1 Terra runs at medium reasoning effort. For buyers, that is a reason to test a route, not a license to move every workload.

GPT-6.1 Terra: what changes in the routing decision

According to OpenAI's announcement, GPT-6.1 Terra at medium reaches parity with GPT-6 Astra on Agents’ Last Exam. GPT-6 Astra's effort setting has not been confirmed. The comparison, published at the October 26 launch and accessed October 28, 2026, does not establish production equivalence.

That distinction matters when a buyer chooses which requests go to which model. An advertised benchmark result can identify a candidate for a trial; it cannot show whether the candidate will perform a particular company's computer-use task under its own interface, data and acceptance rules. The route decision belongs at the level where those conditions can be observed.

Previous coverage of the GPT-6 Astra launch, pricing and safety provides context on the model in the comparison. The practical question is which computer-use task families warrant paired testing. Keep GPT-6 Astra for any family where the new route has not met the acceptance criteria, rather than treating the reported parity as a general replacement instruction.

A route can be approved for one family and held back for another. That is the consequence of measuring the work the buyer actually needs, instead of assuming a public test describes every production request. The decision also needs a way back if accepted quality changes after traffic moves.

OpenAI: GPT-6.1 Terra medium-effort parity and routing

OpenAI reports parity between GPT-6.1 Terra at medium and GPT-6 Astra on Agents’ Last Exam, according to the official announcement accessed October 28, 2026. GPT-6 Astra's effort setting is unconfirmed. The finding supplies a routing hypothesis, not evidence of the lowest cost per accepted result.

The OpenAI API pricing table, accessed October 28, 2026, lists GPT-6.1 Terra Standard input and output at one tenth of the corresponding GPT-6 Astra rates, before any long-context adjustment. A rate describes a charge for tokens. It does not say how many attempts either model will need to finish a buyer's work, or whether the output will meet that buyer's acceptance criteria.

This is not a blanket substitution. The more expensive route can remain justified when the alternative misses the required quality threshold, or when corrections and repeated attempts consume enough of the apparent price advantage that cost per accepted result no longer favors it. A model that produces an answer is not necessarily producing an accepted result.

The analysis of how cost per task determines a route explains that choice. It also points to the unit the buyer can act on: record all attempts behind an accepted result, then compare routes against the same task and the same standard of acceptance.

For a fair comparison, the acceptance rule must exist before the results are inspected. Changing the rule after seeing which route produced an answer would make a cheap route look better without demonstrating that it delivered the work the business requires. The public benchmark is an input to selecting what to test, not the acceptance rule for the test.

Architecture, limits and reasoning effort

OpenAI's documentation specifies GPT-6.1 Terra's context limits and reasoning effort options, but the model sheet consulted does not disclose the architecture, parameter count or quantization. There is no value to infer. Estimates of model size or cost per parameter would lack a documented basis.

The table in the next section brings together the limits from the GPT-6.1 Terra model sheet, accessed October 28, 2026. Record the reasoning effort used in each run. Changing that setting can change consumption and results, making runs difficult to compare when their configurations are not recorded.

Tool calls require the Responses API on OpenAI's API. That requirement does not confirm that the customer's contracted route supports the interface. Before testing, check that the interface passes through the requested effort and tool calls without changing the expected behavior. A test that cannot exercise the required tools does not answer whether the route can perform the intended task.

A large context limit does not remove the need to inspect what enters the request. Sensitive data, persistent instructions and tool outputs each need their own controls. Longer input capacity is a limit on what can be submitted, not a permission to submit material without checking the data and access conditions that apply to it.

The safety addendum, accessed October 28, 2026, is a reference for examining risk. It is not a guarantee that prompt injection or mistaken actions have disappeared. A production trial must account for the actions the model can take, not just the text it returns after those actions.

Benchmarks: where parity starts and ends

On Agents’ Last Exam, a computer-use benchmark, OpenAI reports parity between GPT-6.1 Terra at medium and GPT-6 Astra. The comparison relies on OpenAI's measurement, not independent validation. GPT-6 Astra's effort setting and exact numerical equality of the scores have not been confirmed.

The table combines OpenAI's reported results and API parameters, using sources accessed October 28, 2026. These are different tests and specifications. The model sheet does not disclose architecture, parameter count or quantization. A benchmark score measures behavior, not model construction, so a reported match does not establish that the two routes have the same construction.

The comparison informs a hypothesis. It does not establish that the tasks, interface or tools in the test match those of a particular operation. The Terminal-Bench 4.0 result at max must not be presented as though it were obtained with the medium setting used for GPT-6.1 Terra in the other test.

That separation protects the buyer from making a stronger claim than the source supports. A reported result at one effort level can help select an experiment, while the effort level used in that experiment still has to be recorded alongside consumption, latency and acceptance. A public score is not a substitute for those observations.

The metrics for benchmarking a model router help organize measurement. Set acceptance criteria, serious failure definitions and latency limits for the real task before the comparison, rather than choosing them to match a public test ranking. Include the tool sequence in the evaluation when the task depends on actions, because a final response alone cannot describe every step that led to it.

Inference economics: input, output and cache

GPT-6.1 Terra pricing calls for a comparison of input, output and token cache under the same billing regime. Lower rates do not prove a lower cost per task. The buyer must include cache writes and reads, tool calls, retries and any escalation, without charging the same component twice.

The table uses US dollars per million tokens on OpenAI's Standard API, without the long-context adjustment. Values come from the pricing table and the GPT-6.1 Terra and GPT-6 Astra model sheets, accessed October 28, 2026. These are supplier prices, not a customer's contracted Nexforce Router prices.

The one-tenth relationship applies to input and output, not cache reads. According to the same sources, GPT-6.1 Terra's read rate is one twentieth of the GPT-6 Astra read rate. The list price does not predict savings because the token mix and the number of attempts are unknown.

For GPT-6.1 Terra, the documentation accessed on the same date lists cache writes at $1.25 per million tokens with 30-minute retention and $2.50 with 12-hour retention, before the long-context adjustment. Retention makes sense in the calculation only if reuse is sufficient to compensate for the write charge. A cache read rate on its own omits the cost of establishing the cached input.

Above 272,000 input tokens, the GPT-6.1 Terra model sheet, accessed October 28, 2026, specifies multipliers of 2 times for input and cache and 1.5 times for output across the entire request. They do not apply solely to the amount above the threshold. Comparing a request below the threshold with one above it without recording that adjustment distorts the calculation.

The decision unit is an accepted result. For a defined volume and billing regime, use: cost per accepted result = the sum of charges for fresh input, cache reads and writes, output and tools across every attempt and escalation, divided by the number of accepted results. If no results are accepted, the ratio cannot be calculated.

The formula develops the distinction between token price and cost per task. Tool costs charged in another unit must use their applicable charge rather than being treated as tokens. This keeps the numerator tied to actual billing and prevents a comparison from silently leaving out work that occurred outside a model's token charge.

The denominator matters as much as the numerator. Failed attempts still contribute to the charges even when they do not produce an accepted result. An escalation to the prior route belongs in that same accounting when it is part of completing the task; excluding it would make the new route appear cheaper by moving part of its cost out of view.

Integration and routing in production

Start a migration with representative tasks, acceptance criteria defined before the test, and a paired comparison between routes. Measure cost per accepted result, tool failures and end-to-end latency. Before sending traffic, confirm contracted support, region, data retention and an executable fallback route.

The evaluation needs to capture both response quality and the sequence of actions. In computer-use tasks, failing to locate a field and repeating a read has a different consequence from confirming an operation while the system is in the wrong state. An average can conceal serious failures. Acceptance must reflect the action taken as well as the final response.

Apply the following protocol to existing traffic:

1. Separate real tasks by family and risk, using authorized data. Define what counts as an accepted result and which actions require human review.
2. Run the same tasks on the routes being compared. Record versions, reasoning effort, tools, context and execution conditions, so differences in configuration are visible rather than mistaken for differences between models.
3. Add all charges for each attempt, including cache, tools and escalation. Record acceptance rate and end-to-end latency for each family, without erasing failures that ended in a return to the prior route.
4. Approve only the family that meets the company's limits. Expose traffic in a controlled way, stop sending it if quality, cost or latency moves outside those limits, and test the return route before relying on it.

A correct answer after an improper action is not a success. The acceptance criteria need to reflect that risk, or the test will credit an outcome whose execution the buyer would not permit in production. A route should be approved because the whole task passed, not because its final text looked plausible.

Check quotas, regional availability, retention, cache eligibility and the contracted price. OpenAI's model sheet does not establish that these conditions exist in each customer's environment. Nexforce Router offers per-key rules, tracking and configurable fallback as infrastructure capabilities, but actual support for this model, the requested reasoning effort and the tool interface must be confirmed before testing.

A documented fallback is not the same as an executable one. The buyer should test the return to the prior route before depending on it, and keep the record of failures that triggered that return in the comparison. Otherwise the cost and acceptance figures describe only the portion of traffic that stayed on the new route.

The discussion of routing when token prices change covers governance for route changes. Without a history by task family, a lower invoice does not reveal whether quality also fell. Recording which family was authorized, under which criteria, connects the observed bill to the decision that produced it.

Frequently asked questions

Questions about GPT-6.1 Terra center on price, equivalence and the safety of changing routes. The answers depend on separating OpenAI's published rates from the cost measured on real tasks, and on confirming the environment's technical and commercial conditions before moving production traffic.

Is GPT-6.1 Terra cheaper than GPT-6 Astra?

On OpenAI's Standard API, before the long-context adjustment, GPT-6.1 Terra costs $1.00 for input and $5.00 for output per million tokens. GPT-6 Astra costs $10.00 and $50.00 respectively, according to the pricing table accessed October 28, 2026. Cache has separate conditions. A lower rate does not guarantee a lower cost per accepted result.

The buyer must account for the work behind the accepted result, including attempts, applicable cache charges, tools and escalation. The supplier's listed rate is useful for setting up the comparison; it does not disclose the customer's contracted rate on another route.

Does parity mean the models are equivalent?

No. OpenAI reports parity between GPT-6.1 Terra at medium and GPT-6 Astra on Agents’ Last Exam, as stated in the official announcement accessed October 28, 2026. GPT-6 Astra's effort setting and numerical equality of scores have not been confirmed. The result does not establish equivalence on other tasks or in production.

The claim is also supplier-reported rather than an independent validation. It identifies a comparison worth testing under the buyer's conditions; it does not establish that the production interface, tool sequence or acceptance rules match the benchmark.

What changes in AI model routing?

The new option justifies testing task families using comparable criteria for acceptance, consumption and latency. A family can move to GPT-6.1 Terra if it meets the buyer's limits. Another can remain on GPT-6 Astra, with a return to the prior route if quality falls.

Keeping the decision at the family level prevents a result for one kind of work from becoming an approval for unrelated work. The comparison must include all attempts and the path back, not just requests that finish successfully on the new route.

What should buyers check before migrating?

Confirm model support, modality, reasoning effort, tool interface, region, limits, retention and contracted price. Then test authorized real tasks and record failures, latency and cost per accepted result. Availability in OpenAI's documentation does not confirm availability through Nexforce Router or guarantee the same price for a customer.

The fallback must be executable before traffic depends on it. Record the acceptance threshold and the conditions that trigger a return, so the production decision can be checked against the results rather than inferred from the presence of a new model in supplier documentation.

References and Further Reading

The primary sources identify the launch, benchmark claim, API parameters and pricing conditions used in this analysis, accessed October 28, 2026. Supplier results are not independent reproduction. Prices change.

• OpenAI's GPT-6.1 Terra announcement, accessed October 28, 2026.
• OpenAI API pricing, accessed October 28, 2026.
• GPT-6.1 Terra model sheet and GPT-6 Astra model sheet, accessed October 28, 2026.

The safety addendum, published October 26, 2026 and accessed October 28, 2026, documents the release and risks described by the supplier.

Next step

Keep GPT-6 Astra for task families that have not demonstrated adequate acceptance on the GPT-6.1 Terra route. The person responsible for Nexforce Router should record authorization for each family and tie it to the acceptance criteria, access restrictions and the signal that triggers a return to the prior route.

Without confirmed support, retain the prior route. Do the same when acceptance is insufficient.