OpenAI Fast Mode and the GPT-5.6 Price Cuts: What Every Routing Team Must Change Now

On July 30, OpenAI made three interconnected changes to its API that most teams will notice in different places: Priority Processing was renamed Fast mode, GPT-5.6 Luna got an 80% price cut, and GPT-5.6 Terra dropped 20%. What is not obvious from the announcement is that all three interact — and for teams running routing layers or multi-project API setups, getting the configuration wrong now means either overpaying or silently dropping into standard speeds at the worst moment.

What changed on July 30

Priority Processing renamed to Fast mode. The old service_tier: "priority" parameter now has an alias: service_tier: "fast". Both values are accepted on the Responses API and Chat Completions API, and both deliver the same behavior. The response object still returns priority in the service_tier field even when you send fast — for GPT-5.6 and earlier models. This is backward compatible; nothing breaks if you do not change your code. But you now have a semantic choice to make in your routing config.

GPT-5.6 Luna: 80% price reduction. Luna was already the lowest-cost tier in the GPT-5.6 family. After this cut, it becomes the sharpest cost option OpenAI has offered for a frontier-generation model. The decision point for routing teams is whether Luna's capability ceiling fits the workload — not just whether it is cheaper.

GPT-5.6 Terra: 20% price reduction. Terra was positioned as the balance tier between Luna's throughput and Sol's capability. The 20% cut makes Terra a stronger default for workloads that were previously Sol-or-bust on cost grounds.

GPT-5.6 Sol with Fast mode: up to 2.5x faster than standard. Sol's Fast mode now delivers roughly 2.5x standard speed at 2x the token price. That ratio (2x cost for 2.5x speed) is favorable for latency-sensitive pipelines that were already paying sol-tier rates.

The ramp rate limit operators will miss

Fast mode introduces a ramp rate limit that does not apply to standard processing. If your project sends at least 1 million tokens per minute and increases that rate by more than 50% within a 15-minute window, OpenAI can downgrade affected Fast mode requests to standard speeds — and charge standard rates instead.

When this happens, the service_tier field in the response returns "default" rather than "priority". If you are not logging and checking service_tier in responses, you will have no indication that the downgrade happened until you notice a latency spike or audit costs after the fact.

Named failure modes this creates:

• Silent performance regressions during traffic spikes. An agent swarm that fans out simultaneously, a batch pipeline that starts all at once, or a load test that ramps too fast — any of these can trigger the downgrade. If your routing layer assumes Fast mode is always fast, downstream SLAs become unreliable.
• ETL and batch jobs must not use Fast mode. OpenAI's documentation explicitly calls this out. Running extraction or transformation pipelines at scale on Fast mode wastes the premium and is the workload type most likely to trigger the ramp limit.
• Feature-flag your Fast mode migration. When enabling Fast mode project-wide, shift traffic over hours rather than all at once.

The router/operator angle

Project-level versus request-level Fast mode configuration. Fast mode can be set at the request level (service_tier: "fast" per call) or at the project level via the platform dashboard. Project-level is convenient — requests without a tier default to Fast — but it removes per-call granularity. For teams routing multiple workload types through a single project, this becomes a misconfiguration risk: batch jobs, background indexing, and user-facing real-time calls each need different service tier policies.

The correct routing setup after this change:

1. User-facing, latency-sensitive calls (chat completions, agent turns, coding completions): set service_tier: "fast" explicitly at the request level.
2. Background, batch, and ETL workloads: set service_tier: "default" explicitly. Never run these on Fast mode at throughput scale.
3. Your routing selector evaluates model and workload type, then injects service_tier before forwarding to OpenAI.

Model re-scoring after the price cuts. The 80% Luna price cut widens the cost spread across the GPT-5.6 family significantly. For workloads that settled on Terra as a compromise between Sol's quality and Luna's budget, it is worth re-running evals against Luna. The capability gap between Luna and Terra may no longer justify the cost difference at current prices.

Cross-provider context: how three providers handle the same capacity problem differently. OpenAI's ramp rate limit is rate-of-change-based: you can run at high throughput indefinitely, but you cannot spike traffic faster than 50% growth per 15 minutes. DeepSeek's peak-hour pricing is time-of-day-based: cost rises during peak hours regardless of whether your traffic spiked. Anthropic fast mode was deprecated entirely because it created dual failure modes for operators. Each provider solves the same capacity management problem differently — your routing policy needs to encode the correct rule per upstream, not assume they all behave the same.

Add service_tier to your response logging. The backward-compatible rename from priority to fast is the right prompt to audit your response parsing. If your logging layer does not capture service_tier from responses, you cannot detect the ramp-rate downgrade. The signal to watch: "default" appearing in responses where you sent "fast" or "priority".

What TheRouter users should watch or try

Immediate audit checklist:

• Check whether any of your OpenAI projects have Project Service Tier set to Fast at the project level. If yes, confirm that no batch or ETL pipelines run through those projects.
• Add service_tier to your response field capture and alert on "default" when you expected "fast".
• Re-run capability evals for Luna on your current Terra workloads. The 80% price delta is large enough to justify a fresh benchmark pass.
• For Sol with Fast mode on user-facing workloads, measure the latency improvement in your production distribution before committing to the 2x price premium.

TheRouter's per-route config supports injecting service_tier as a parameter per model assignment. After this change, the recommended pattern: Sol with service_tier: fast for synchronous user-facing routes; Luna or Terra with service_tier: default for any batch path that could exceed 1M TPM.