# GPT-6 Astra, Sol or Luna: choosing a tier per task

URL: https://infro.io/blog/gpt-6-astra-sol-luna-tiers
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-09-29
Last modified: 2026-09-29
Last reviewed: 2026-09-29 (next review due 2026-10-29)
Topic: Evaluation and models
Format: Comparison

> GPT-6 Astra, Sol and Luna all have a 1.05M-token context window, 128K output, text and image input, structured outputs and function calling; their standard list rates are $10/$50, $2/$10 and $0.10/$0.50 per million input and output tokens. Choose per task, not per application: evaluate each task type on the lowest tier first, move up only when it fails your check, and route each task tier to the tier that passed.

Key takeaways:
- Astra, Sol and Luna differ in list rate, not in context window, output limit or modalities.
- Luna's standard rates are one hundredth of Astra's; even a much lower pass rate can leave it ahead on cost per successful task.
- Reasoning effort is a second dial inside each tier. Sol and Luna accept none; Astra starts at low.
- Batch and flex halve the standard rate on all three; fast mode doubles it.
- Decide per task type and encode the decision in routes, so a tier change is a configuration edit with a recorded result.

OpenAI's GPT-6 family has three tiers. GPT-6 Astra is described as "our most capable model", GPT-6 Sol as built for complex coding and agentic workflows, and GPT-6 Luna as the most efficient model for focused, high-volume tasks[1]. What makes the family interesting for production is what the three share: the same context window, the same output limit, the same input modalities and the same core features. The main published difference is the rate.

That makes the tier a routing decision rather than a platform decision. This article sets out the published facts and a method for choosing a tier per task.

## What the three tiers share

According to OpenAI's model pages, all three have a 1.05M-token context window and 128K maximum output tokens, take text and image input, produce text, and support streaming, structured outputs, function calling, file search, web search and prompt caching; all three are available on Chat Completions, Responses and Batch[2][3][4]. Sol and Luna list fine-tuning as unsupported[3][4].

[Diagram: Published facts for the three GPT-6 tiers, read from OpenAI's model and pricing pages on 2026-09-29.]

The differences that are published:

- **Knowledge cutoff.** Astra: April 30, 2026. Sol: April 20, 2026. Luna: May 18, 2026[1]. The smallest tier has the latest cutoff.
- **Reasoning effort.** Astra accepts `low` through `max`; Sol and Luna also accept `none`[1]. A tier at high effort and the tier above it at low effort are different operating points, and both are worth testing.
- **Rates.** The standard rates are two orders of magnitude apart.

## List rates, and the other processing tiers

[Diagram: Standard-tier list rates per million tokens for prompts up to 272K input tokens, from OpenAI's pricing page on 2026-09-29.]

Standard rates per million tokens are $10 input and $50 output for Astra, $2 and $10 for Sol, and $0.10 and $0.50 for Luna[5]. Cached input is $1.00, $0.20 and $0.01; cache writes are $12.50, $2.50 and $0.125[5]. See the [GPT-6 Astra](https://infro.io/models/openai/gpt-6-astra), [GPT-6 Sol](https://infro.io/models/openai/gpt-6-sol) and [GPT-6 Luna](https://infro.io/models/openai/gpt-6-luna) model pages for the catalog entries.

OpenAI publishes three other processing tiers for each model[5]:

| Tier | Astra in / out | Sol in / out | Luna in / out |
| --- | --- | --- | --- |
| Batch | $5 / $25 | $1 / $5 | $0.05 / $0.25 |
| Flex | $5 / $25 | $1 / $5 | $0.05 / $0.25 |
| Standard | $10 / $50 | $2 / $10 | $0.10 / $0.50 |
| Fast mode | $20 / $100 | $4 / $20 | $0.20 / $1.00 |

Table: Per-million-token rates for prompts up to 272K input tokens, as published 2026-09-29.

Above 272K input tokens, the full request is billed at 2x input and cache rates and 1.5x output on all three[3][4][5]. OpenAI charges a 10% uplift on regional processing endpoints for models released on or after March 5, 2026, and notes that EU data residency for Sol and Luna is available only with standard processing[5].

Two consequences follow. A workload nobody waits for can often move a tier down in processing (batch or flex) instead of a tier down in model. And a workload that needs fast mode doubles its rate, so the tier choice matters more there, not less.

## Why "the smallest model that passes" is the rule

With rates this far apart, the arithmetic strongly favours trying the lower tier first. A lower tier that fails more often can still cost less per successful task, as long as failures are detected and retried on a higher tier.

> **Example: Cost per successful task across tiers**
> Illustrative. A classification task averages 3,000 input and 300 output tokens. At standard rates: Luna $0.00045, Sol $0.009, Astra $0.045 per request. Suppose on your eval set Luna passes 88%, Sol 97% and Astra 98%.
> 
> Luna alone: $0.00045 ÷ 0.88 = $0.00051 per success. Sol alone: $0.0093. Astra alone: $0.0459.
> 
> Luna first, failures retried on Sol: 1,000 requests cost $0.45 on Luna plus 120 × $0.009 = $1.08 on Sol, $1.53 for about 996 successes — roughly $0.0015 each. The pass rates here are invented; yours will differ, which is the point of measuring them.

The rule has limits. Some tasks fail silently — a plausible but wrong summary passes any shallow check — and a lower tier with silent failures is not less costly, it is less visible. Where you cannot check an output automatically, sample it for human review before trusting a lower tier.

## Effort is a second dial inside each tier

Every GPT-6 tier accepts a reasoning effort, and Sol and Luna accept `none`[1]. Effort changes how many output tokens a request consumes before the visible answer, so it moves cost and latency without changing the model. That creates operating points that overlap across tiers: Luna at high effort may pass a task that Luna at `none` fails, at a cost still well below Sol at low effort — or it may not. Neither the rate card nor the model description tells you which.

Treat effort as part of the configuration under test. For each task type, test at least two effort levels on the lower tier before moving up a tier, and record output tokens per request alongside the pass rate. A tier comparison run at default effort on both sides answers a narrower question than the one you are deciding.

## Processing tier or model tier

Before moving a workload down a model tier, check whether it can move down a processing tier instead. OpenAI lists batch and flex at half the standard rate for all three models[5], so a nightly Sol job sent through batch bills at $1 input and $5 output per million tokens.

> **Example: Nightly summaries: two ways to halve the rate**
> Illustrative. A nightly job summarizes 50,000 records, each 4,000 input and 400 output tokens, on Sol at standard rates: 200M input tokens × $2 + 20M output × $10, per million = $400 + $200 = $600 a night. Through batch at $1 and $5: $300. Moving to Luna at standard rates instead: $20 + $10 = $30, if Luna passes the task. Batch keeps the model you evaluated and changes only when results arrive; a tier change changes behaviour and needs its own evaluation. Both options can apply together.

The opposite also holds. A latency-sensitive feature that needs fast mode doubles its rate on every tier[5], so the case for testing a lower tier is strongest exactly where a user is waiting.

## A method for choosing per task

[Diagram: A routing decision per task type. Start at the lowest tier that passes your own check; move up only on evidence.]

1. **List your task types.** Classification, extraction, drafting, agentic multi-step work and code changes rarely need the same tier. One application can have five.
2. **Write a check for each.** Schema validity, exact-match labels, tests passing, a rubric a reviewer applies to a sample.
3. **Start at Luna, then Sol, then Astra**, at the reasoning effort you would ship. Record pass rate, output length and cost per request.
4. **Pick the lowest tier that meets the pass rate you need**, and a fallback target for when it is unavailable.
5. **Re-run when a snapshot or rate changes.** OpenAI lists a single snapshot per model on each page[2][3][4]; when that changes, so can your results.

## Routing GPT-6 tiers with INFRO routes

Encode each decision as a [route](https://infro.io/docs/routes): a stable name the application sends as `model`, backed by an ordered list of targets on your own connections. Routes are configured in the console under Routing.

| Route slug | Strategy | Targets, in order |
| --- | --- | --- |
| `ticket-triage` | priority | `openai/gpt-6-luna`, then `openai/gpt-6-sol` |
| `support-drafts` | priority | `openai/gpt-6-sol`, then `openai/gpt-6-luna` |
| `contract-review` | priority | `openai/gpt-6-astra`, then `openai/gpt-6-sol` |

Table: An example route plan. Each target names a connection and a model.

The application sends the route slug and nothing else changes:

```json
{
  "model": "ticket-triage",
  "messages": [{"role": "user", "content": "Customer says the export button does nothing."}],
  "metadata": {"feature": "ticket-triage"}
}
```

A route's second target is a failover target: it runs when the first fails before any response has started, not when the first answer is poor ([routing](https://infro.io/docs/features/routing)). Quality-based escalation — retrying on Sol because Luna's output failed your check — stays in your application, which knows what a failed check is.

To test a tier change on live traffic, a `weighted` route can send a small share of requests to the new tier first; it still falls through to the other targets on failure, so group results by the model that served ([routes](https://infro.io/docs/routes)). `GET /v1/usage?group_by=route` or `group_by=feature` then returns requests, estimated provider cost, error rate and latency percentiles per route or feature ([usage analytics](https://infro.io/docs/observability/analytics)).

Two controls keep the plan honest. A [model allowlist](https://infro.io/docs/org/model-allowlists) on a project or key can exclude `openai/gpt-6-astra` where it has no approved use, and route targets are checked against it. And a key can be pinned to named routes, so it cannot call a model directly around the plan ([routes](https://infro.io/docs/routes)). Every request is billed by OpenAI to your own account; INFRO estimates that cost and records it, and its subscription is billed separately.

## Questions

### Can GPT-6 Luna or Sol be fine-tuned?

OpenAI's model pages for GPT-6 Sol and GPT-6 Luna list fine-tuning as not supported, as of 2026-09-29. Check the model page before planning around it, since supported features change.

## Sources

1. Models — OpenAI. https://developers.openai.com/api/docs/models (accessed 2026-09-29)
2. GPT-6 Astra — OpenAI. https://developers.openai.com/api/docs/models/gpt-6-astra (accessed 2026-09-29)
3. GPT-6 Sol — OpenAI. https://developers.openai.com/api/docs/models/gpt-6-sol (accessed 2026-09-29)
4. GPT-6 Luna — OpenAI. https://developers.openai.com/api/docs/models/gpt-6-luna (accessed 2026-09-29)
5. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-09-29)