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

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¹. 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²³⁴. Sol and Luna list fine-tuning as unsupported³⁴.

The differences that are published:

• Knowledge cutoff. Astra: April 30, 2026. Sol: April 20, 2026. Luna: May 18, 2026¹. The smallest tier has the latest cutoff.
• Reasoning effort. Astra accepts low through max; Sol and Luna also accept none¹. 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

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⁵. Cached input is $1.00, $0.20 and $0.01; cache writes are $12.50, $2.50 and $0.125⁵. See the GPT-6 Astra, GPT-6 Sol and GPT-6 Luna model pages for the catalog entries.

OpenAI publishes three other processing tiers for each model⁵:

Above 272K input tokens, the full request is billed at 2x input and cache rates and 1.5x output on all three³⁴⁵. 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⁵.

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.

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¹. 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⁵, so a nightly Sol job sent through batch bills at $1 input and $5 output per million tokens.

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

A method for choosing per task

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²³⁴; when that changes, so can your results.

Routing GPT-6 tiers with INFRO routes

Encode each decision as a route: 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.

The application sends the route slug and nothing else changes:

{
  "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). 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). 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).

Two controls keep the plan honest. A model allowlist 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). Every request is billed by OpenAI to your own account; INFRO estimates that cost and records it, and its subscription is billed separately.