A model lineup is a pricing portfolio
OpenAI's GPT-6.1 Terra cuts price 50% while keeping the premium tier intact. The product lesson for PMs building on top of AI APIs is that model choice is cost architecture, not just capability selection.
On this page 5 sections
- Model tiers segment by task cost tolerance, not just capability.
- A 50% price cut on the mid-tier forces you to re-evaluate which tasks justify the premium model.
- Track cost per completed task, not cost per token, to choose the right tier.
- A pricing wedge reshapes your product's unit economics before you change a line of code.
OpenAI released GPT-6.1 Terra on October 26, 2026 at $1 per million input tokens and $5 per million output tokens — 50% below both GPT-5.6 Terra and GPT-6.1 Sol. It matches GPT-6 Astra on computer-use benchmarks at roughly one-tenth the price per token. The headline capability is “fast and capable computer use at scale,” but the more interesting signal is what the pricing structure tells product teams building on these APIs.
The mid-tier is not a downgrade#
Terra is not a stripped-down version of the flagship. On Agents’ Last Exam, it scores within range of Astra at medium reasoning effort. On MMMU-Pro (visual reasoning), it nearly matches both Astra and Sol. The hallucination rate on error-inducing prompts dropped from 53.6% to 16.7% at low effort compared to the previous Terra generation.
This is meaningful because it changes the decision from “which model is best” to “which tasks actually need the premium tier.” If Terra handles invoice reading, form filling, and document drafting at a comparable quality level, the only reason to use Astra is tasks where its remaining edge — the hardest code, the most complex multi-step reasoning — is the bottleneck.
Price cuts create re-architecture decisions#
A 50% price drop does not just save money on existing usage. It makes previously uneconomical tasks viable. An application that could not justify AI-assisted data entry at $2 per million input tokens might clear the business case at $1. That is not a small operational tweak — it changes what you build next.
For a PM managing an AI-powered product, the practical questions after a pricing shift like this are:
- Which tasks are currently on the premium tier that Terra could handle? Run a sample of production inputs through Terra and compare output quality. If completion rates and accuracy are within your error budget, migrate those tasks and redeploy the savings.
- Which tasks were rejected on cost grounds? Re-run the unit economics. A task that cost $0.12 per completion on Sol might cost $0.06 on Terra. If your product charges $0.50 per use, that margin change is significant.
- Where does latency matter more than capability? Terra completes tasks over three times faster than Astra. For user-facing features where wait time affects conversion, the faster model at lower cost is the better product choice even if the premium model scores a few points higher on a benchmark.
Track cost per task, not cost per token#
Token pricing is a proxy, not the metric that matters. Two models at the same per-token price can have very different costs per completed task if one uses fewer tokens or fewer retries to reach the same outcome.
OpenAI’s own framing hints at this: they report that Terra is “over three times as token efficient as Claude Opus 5.5” on computer-use tasks, resulting in roughly 9x lower cost per task. The efficiency gain compounds with the price cut.
A useful internal dashboard for any PM shipping on top of LLM APIs tracks three numbers per task type:
| Metric | What it tells you |
|---|---|
| Cost per completed task | The real unit cost, including retries and token overhead |
| Completion rate | Whether the model finishes the task without human rescue |
| Latency (p50 and p95) | Whether speed is a user-experience constraint |
If you only track cost per token, you will miss the moment when a cheaper model actually delivers a lower cost per task because it is more efficient. You will also miss the moment when a premium model is worth its price because it avoids expensive failure recovery.
A lineup is a portfolio strategy#
What OpenAI is doing with Terra, Sol, and Astra is not just releasing better models. It is building a pricing portfolio: a set of options at different price-performance points, each designed to capture a segment of demand that the others leave on the table.
This is a familiar pattern in enterprise software (Salesforce editions, AWS instance families), but it is newer in the foundation-model market. For PMs building downstream products, it creates real work. You need to map your task types to model tiers, set rules for when to route up or down, and monitor whether the boundaries are still right after each new release.
The risk of not doing this is straightforward: you either overpay by using the premium tier for every request, or you under-deliver by using the cheapest model for tasks that need more capability. Neither is a good default.
The decision rule#
After a major pricing shift like Terra, I would run this sequence:
- Inventory your task types by volume, current model, and current cost per completion.
- Sample-test the new tier on your top-five highest-volume task types.
- Compare completion rate and quality against your error budget, not against the premium model’s maximum score.
- Migrate tasks where the new tier meets the bar, and track the cost and quality delta for two weeks before committing.
- Re-evaluate rejected features that failed on unit economics at the old price point.
A model launch is not just a capabilities announcement. For product teams consuming these APIs, it is a pricing event that can reshape your product’s cost structure overnight. The teams that treat model selection as an ongoing portfolio decision — not a one-time architecture choice — will capture the margin before their competitors notice the price moved.