OpenAI Slashes Luna Pricing 80%, but Agent Costs Barely Budge
GPT-5.6 Luna Price Cut by 80%: What Agents Really Need to Recalculate is the Cost Per Success
TL;DR
- Scenario: OpenAI's 2026-07-30 announcement that Luna Standard short-context rates for four items are simultaneously reduced to 20% of the old price (i.e., an 80% price cut); a homogeneous Luna Token bill drops exactly 80%.
- Conclusion: Cheap model tokens do not mean a cheap single successful task. The total cost of an agent task also includes tool calls, loop retries, long-context step jumps, cache mismatches, and human review; the true value of migration is determined by
cost_per_success. - Output: Complete rate equation (4 items × 0.2) + tool cost inflection point (Web Search 0.01 > example Token 0.0064) + 272K long-context step jump (2× input / 1.5× output) + cache hit ordering suggestion + cost_per_success formula and comparison table + 100-500 real task A/B matrix + Luna-first three-tier conditional upgrade plan + 30-day migration rhythm.
Version Matrix
| Dimension | Status | Description |
|---|---|---|
| Luna Standard short-context four rates simultaneously reduced to 20% of old price | ✅ Verified | Input 1.00 → 0.20 / Cache read 0.10 → 0.02 / Cache write 1.25 → 0.25 / Output 6.00 → 1.20 (USD / million Tokens) |
Equation new = 0.20 × old |
✅ Verified | Same Luna model / same service tier / same context interval / same Token vector |
| Luna context capacity | ✅ Verified | 1,050,000 token context / 128,000 max output |
| 272K long-context step jump | ✅ Verified | After input > 272K, the complete request is billed at 2× input + 1.5× output rates (Standard corresponding: input 0.40 / cache read 0.04 / cache write 0.50 / output 1.80) |
| OpenAI announcement date | ✅ Verified | API pricing effective from 2026-07-30; Sol simultaneously adds Fast mode |
| Terra synchronous price cut | ✅ Verified | Terra synchronous price cut 20%: input $2/M, output $12/M |
| Web Search fixed call fee | ✅ Verified | $10.00 / 1k calls (price difference exists between reasoning and non-reasoning models; non-reasoning preview $25.00/1k) |
| Web Search content Tokens | ✅ Verified | Search content Tokens are billed separately |
| Container / Code Interpreter | ✅ Verified | Billed per 20-minute session |
| File search | ✅ Verified | Storage $0.10/GB-day; Tool call $2.50/1k calls |
| Agent Kit | ✅ Verified | ChatKit file/image upload storage $0.10/GB-day |
| Cache read = 10% of input | ✅ Verified | Luna Standard: cache read 0.02 / input 0.20 = 10% |
| Cache write > normal input | ✅ Verified | Luna Standard: cache write 0.25 / input 0.20 = 1.25× |
| Luna-first upgrade conditions | ✅ Verified | Upgrade on failure / low confidence / complex tasks; high-risk retains human responsibility |
| "Cheap model Tokens = cheap total task cost" | ❌ Not true | Tools, loops, human amortization, 272K step jump are all billed independently |
| "Use Benchmarks to decide migration" | ❌ Not true | Must use cost_per_success from 100-500 real tasks |
| "Luna-only replaces all tasks" | ❌ Not true | High error cost / hard-to-auto-verify tasks still need Terra/Sol final review + human |
| "Average context 200K ≠ stable cost" | ❌ Not true | Must look at P50/P90/P95/P99 + 272K step jump + last tool call before crossing the line |
| "More cache writes is better" | ❌ Not true | Writing without reading is waste; writing is beneficial only when the prefix will be reused |
| "New price = any context, any Token, uniform" | ❌ Not true | 272K step jump + cache read/write/input are priced separately |
| "Web Search drops together with model Tokens" | ❌ Not true | Tool fees are billed separately; fixed call fees are not linked to Token prices |
| "Luna auto-verification = can remove human review" | ❌ Not true | High-risk decisions retain human responsibility |
Article Body
GPT-5.6 Luna Price Cut by 80%: What Agents Really Need to Recalculate is the Cost Per Success
Factual Boundary: This article is verified against the OpenAI announcements, Luna model card, and API pricing page accessible as of 2026-07-31. A price cut does not mean model weights have changed, nor can it be used to deduce OpenAI's unit inference cost or gross margin.
Abstract
Luna Standard short-context input, cache read, cache write, and output prices have all dropped to 20% of the old price. Therefore, when the model, service tier, context interval, and Token composition remain unchanged, the model Token bill drops exactly 80%. But agent tasks also include tool calls, loop retries, long-context step jumps, cache mismatches, and human review. The metric that truly determines migration value should be cost_per_success. This article provides the complete rate equation, tool cost inflection point, 272K threshold, 100–500 real task A/B, and a Luna-first conditional upgrade plan.
Keywords
GPT-5.6 Luna, cost_per_success, 272K threshold, Web Search, Luna-first
Table of Contents
- 1. 80% is a strict equation, but with four prerequisites
- 2. Model fees drop 80%, why total task cost might not
- 3. After Tokens get cheaper, tools become the cost center sooner
- 4. 272K is a discrete price step jump for the complete request
- 5. Cache hits belong to the billing architecture
- 6. Migration main metric: cost_per_success
- 7. Use 100–500 real tasks for A/B testing
- 8. Luna-first, not Luna-only
- 9. 30-day migration rhythm
- Conclusion
- References
1. 80% is a strict equation, but with four prerequisites
OpenAI's currently listed Luna Standard short-context rates are:
| Billing Item | Old Price | New Price | Unit |
|---|---|---|---|
| Uncached Input | 1.00 | 0.20 | USD/million Tokens |
| Cache Read | 0.10 | 0.02 | USD/million Tokens |
| Cache Write | 1.25 | 0.25 | USD/million Tokens |
| Output | 6.00 | 1.20 | USD/million Tokens |
Let the four types of Tokens be I, R, W, O:
old = 1.00I + 0.10R + 1.25W + 6.00O
new = 0.20I + 0.02R + 0.25W + 1.20O
= 0.20 × old
This equation is only valid when four conditions are met simultaneously: the same Luna model, the same service tier, the same context rate interval, and the same Token vector. Tool, region, and third-party fees are not included in the equation.
2. Model fees drop 80%, why total task cost might not
Agent task costs at least include:
Model Tokens
+ Tool Calls
+ External Services
+ Retries & Loops
+ Human Review
Assume old model Token cost is $0.10, tools $0.03, human review amortization $0.07, total cost is $0.20. After the model portion drops 80%, total cost becomes:
0.02 + 0.03 + 0.07 = $0.12
Total business cost only drops 40%. If Luna requires more turns, searches, or human intervention, a single call is cheaper, but a single successful task might not be cheaper at all.
3. After Tokens get cheaper, tools become the cost center sooner
OpenAI's current Web Search fixed call fee is $10 per 1,000 calls, i.e., $0.01 per call, with search content Tokens billed separately.
A single Luna Standard request with 20K uncached input and 2K output:
20K × $0.20/M + 2K × $1.20/M = $0.0064
The fixed fee for one Web Search is already higher than the model Token cost. This doesn't mean agents should stop searching, but it requires teams to record tool_calls_per_success, duplicate searches, resultless searches, and the success rate improvement after searching. Evidence that needs to be searched still must be searched; runaway loops must be cut off by the Harness.
4. 272K is a discrete price step jump for the complete request
Luna supports 1,050,000 context, max output 128,000; but once input exceeds 272K, the complete request is billed at 2× input and 1.5× output rates. For Standard, this corresponds to input 0.40, cache read 0.04, cache write 0.50, output 1.80 USD/million Tokens.
An average context of 200K cannot prove cost stability. Teams need to look at P50/P90/P95/P99, the cross-line ratio, and the last tool call before crossing the line. They can warn and compress confirmed state at 240K–260K, but if high-risk tasks must retain complete evidence, they should accept the long-context rate.
5. Cache hits belong to the billing architecture
Cache read price is one-tenth of normal input, but hits depend on a stable prefix. Placing timestamps, user state, or the latest tool results at the front of the Prompt prevents subsequent stable instructions from being reused.
A more reasonable order is:
Stable instructions
Stable tool definitions
Stable task rules
Dynamic user state
Latest tool results
Current request
Cache write price is higher than normal input. Writing is only potentially beneficial when the prefix will be reused. Therefore, read rate, write rate, prefix reuse count, and the ratio of writes that are never read must be observed simultaneously.
6. Migration main metric: cost_per_success
First, define verifiable "success" for the task: code tasks can require tests, static checks, and patch audits; retrieval tasks can require key conclusions with accessible sources; structured extraction can require schema and sampling to pass together.
Then calculate:
cost_per_success
= All attempted model fees
+ All tool fees
+ External service fees
+ Human review amortization
--------------------------------
Number of successful tasks
The comparison table at least includes:
- First-attempt success rate and number of critical errors;
- Cost per single success;
- P50/P95 end-to-end latency;
- Retries, model turns, tool calls, and output Tokens per success;
- Cache read rate, human review minutes, and upgraded model distribution.
7. Use 100–500 real tasks for A/B testing
The sample should cover low-risk verifiable, medium uncertainty, high error cost, long context, heavy tool call, and historical tail failure tasks. Compare under the same Harness, tool budget, and verifier:
A: Current production routing
B: Luna-first + same verifier + conditional upgrade
The pass condition is not "average score looks good," but that the success rate is within tolerance, P95 does not exceed budget, cost_per_success steadily decreases, critical errors are 0, and tool loops, human review, and upgrade rates do not abnormally rise.
8. Luna-first, not Luna-only
Low uncertainty + auto-verifiable + high call volume
-> Luna first
Medium uncertainty + user-visible + clear acceptance criteria
-> Luna / Terra A/B, upgrade on failure
High uncertainty + high error cost + hard to auto-verify
-> Terra / Sol plan and final review, Luna executes verifiable sub-tasks
Upgrade conditions should be system-observable: schema or test failure, source conflict, insufficient confidence, tool loop exceeding limit, long context approaching threshold and cannot be safely compressed, and irreversible, financial, legal, or safety risks.
9. 30-day migration rhythm
- Days 1–3: Export model, tool, retry, and human review baselines; unify success definitions.
- Days 4–10: Low-risk small-traffic comparison; daily reconciliation of local estimates and real bills.
- Days 11–20: Include medium uncertainty and long context; observe P95 and tail failures.
- Days 21–30: Solidify upgrade and rollback thresholds; high-risk tasks retain Terra/Sol.
When task volume is very small, the engineering cost of maintaining multi-model routing may exceed the savings; continuing to use a single strong model is a reasonable simpler option. Auto-verifiers also cannot replace human responsibility in high-risk tasks.
Conclusion
It can be precisely stated: a homogeneous Luna Token bill drops 80%.
It must be answered through experimentation: how much did your cost per single successful task drop?
Luna's new price makes a large number of verifiable tasks economically viable for Luna-first, but truly sustainable gains come from success definitions, tool budgets, context governance, real task A/B, conditional upgrades, and rollback-able run contracts.
References
- OpenAI: GPT-5.6 Price Performance Announcement
- OpenAI Developers: GPT-5.6 Luna Model Card
- OpenAI Developers: API Pricing
- OpenAI: GPT-5.6 Efficiency Note
Error Quick Reference Card
| Symptom | Root Cause | Diagnosis | Fix |
|---|---|---|---|
| Treating "model Token bill drops 80%" as total task cost dropping 80% | Tools / external services / retries / human amortization are billed independently | Check each component of the cost_per_success formula | Replace single model fee comparison with cost_per_success |
| Web Search suddenly becomes the cost center | Tool fixed call fee > model Token fee | Check tool_calls_per_success / duplicate searches / resultless searches | Record duplicate searches and success rate improvement; use Harness to cut off runaway loops |
| Long-context tasks exceed budget | After input > 272K, the complete request is billed at 2× input / 1.5× output rates | Check P50/P90/P95/P99 + cross-line ratio | Warn and compress at 240K-260K; accept long-context rate for high-risk tasks |
| Cache hit rate still low | Timestamps / user state / tool results placed before stable prefix | Check prompt order | Stable instructions / tool definitions / task rules → dynamic user state → latest tool results → current request |
| Cache writes never read | Cache write > normal input; only beneficial when prefix will be reused | Check ratio of writes never read | Observe read rate / write rate / prefix reuse count; writing without reading is waste |
| Announcing migration based on high benchmark scores | Benchmark ≠ real tasks; Benchmarks cannot cover tool loops / long context / error cost | Lack of real task A/B | Use 100-500 real tasks for A/B; fix task set, tools, retry rules, and quality thresholds |
| "Luna-only" replaces all tasks | High error cost / hard-to-auto-verify tasks still need Terra/Sol final review | Task classification table | Luna-first three tiers: Low uncertainty → Luna / Medium → A/B upgrade / High → Terra/Sol + human |
| Average context 200K proves cost stability | Average hides P99 crossing the line + last tool call before crossing | Check P99 + last tool call before crossing | Replace average with P50/P90/P95/P99 + cross-line ratio + last tool call before crossing |
| Treating "upgrade rate" as an optimization signal | High upgrade rate may indicate routing conditions are too strict or task classification is wrong | Upgrade rate linked with success rate / cost_per_success | Upgrade rate must be a mandatory recorded metric linked with first-attempt success rate / critical error count |
| Tool loop out of control | Harness has no cut-off conditions set; Harness still believes "the model just needs to try harder" | Check tool loop count / resultless searches | Harness must set max loop count / resultless search cap / failure fallback |
| Maintaining multi-model routing when task volume is small | Routing engineering cost > savings | Task volume / routing code maintenance cost | Continue using a single strong model when task volume is small; routing is a scale benefit |
| Luna tasks "bring down" the average cost | Average price dominated by short-context low rates | Split cost distribution above and below 272K | Reports must be segmented by the 272K step jump, cannot be merged |
| Human review replaced by auto-verifier | Auto-verifier cannot handle high-risk decisions | Task grading | High-risk decisions retain human responsibility; auto-verifier only replaces verifiable parts |
| "Luna auto-success" treated as total success | Tail failures that Luna cannot pass are still covered by upgraded models | Check ratio of upgrades to stronger models | Reports must distinguish the split of Luna first-round success / success after upgrade / final failure |
| Treating 1.05M context as default capability | 272K step jump; cache write / cache read / tool fixed fees are all billed independently | Check cross-line ratio and cache hit distribution | 272K is a rate step jump; exceeding it means long-context rates; 1.05M is not "use freely" |
| Generalizing new price to any context interval | 272K long-context rate is higher than short-context | Check 272K cross-line ratio | Standard long-context: input 0.40 / cache read 0.04 / cache write 0.50 / output 1.80 |
| "Luna input 0.20 = entire request 0.20" | Four rates are independent; output / cache write / tools are not in input | Split the four Token types | Reports must display I / R / W / O four items separately |
Author: Wu Zikang's Personal Blog