# Which GPT model to use: Sol, Astra or Luna?

> Sol for most work, Astra for the hardest reasoning and coding, Luna for fast, high-volume tasks. How OpenAI's GPT models compare on cost and fit.

Updated: 2026-11-01

Use Sol for most work: OpenAI describes it as close to Astra on complex tasks, at a fifth of Astra's price per input and output token. Move to Astra for the hardest reasoning, coding and professional work. Use Luna for focused, high-volume tasks where speed and a low price matter most.

## Which GPT model fits which task?

OpenAI's current GPT line trades speed for capability: Luna is the fastest and lowest priced, Sol sits in the middle, and Astra is the most capable. This table uses the wording of OpenAI's own model guide:

| Your task | Model | Why |
| --- | --- | --- |
| Everyday coding, agents that call tools, writing, analysis | Sol | "Balanced speed, cost, and intelligence", with "near-Astra performance for complex work at a lower cost" |
| The hardest reasoning and coding, long multistep work across code, browsers and professional software | Astra | "Highest intelligence", made "for the most demanding reasoning, coding, and professional work" |
| Classification, extraction, tagging, short answers at scale | Luna | "Fastest and most cost-effective", with "strong performance for focused, high-volume tasks" |

OpenAI also offers Terra, a fast model for visual reasoning and computer use, covered in the questions below. In short: start with Sol, move up to Astra when a task needs more, and down to Luna for jobs you repeat many times.

## The GPT models you can use today

This list comes from our live catalog, so it shows the current versions and our price per million tokens:

| Model | Id | Input (ours) | Output (ours) | Context |
| --- | --- | --- | --- | --- |
| GPT-6.1 Sol | `gpt-6.1-sol` | $0.60 | $3 | 922K |
| GPT-6 Astra | `gpt-6-astra` | $3 | $15 | — |
| GPT-6 Sol | `gpt-6-sol` | $0.60 | $3 | 922K |
| GPT-6 Luna | `gpt-6-luna` | $0.03 | $0.15 | 922K |

When two versions of Sol appear, the higher version number is the newer one. Older versions stay on the models page for code that still uses them.

## Sol: the model for most work

OpenAI calls Sol its balance of "speed, cost, and intelligence", with "near-Astra performance at a lower cost for complex coding" and professional work. That makes it the sensible starting point for coding, agents that use tools, writing and data analysis.

Sol supports five reasoning effort levels: `low`, `medium` (the default), `high`, `xhigh` and `max`. If you already use the older Sol, OpenAI asks you to "review the migration guidance" before you switch, because the two versions don't take the same settings. For example, the older version also accepts a `none` effort level and the newer one doesn't.

## Astra: for the hardest work

Astra is OpenAI's most capable model. OpenAI reports state-of-the-art results in computer use, browsing, software engineering, science and professional work, and says it "can carry out multi-step workflows across code, browsers, and professional software". It supports the effort levels `low` through `max`, with no `none` level.

Astra costs five times Sol's price per input and output token, and ten times per cached token. OpenAI's case for it is that it needs fewer tokens: in OpenAI's evaluations, Astra "achieved stronger results using substantially fewer output tokens", and its estimated cost per task "was lower than earlier models despite its higher per-token pricing". That comparison is with earlier models, not with the newer Sol, so test Astra on your own tasks before you pay its price for routine work.

## Luna: for fast, high-volume work

Luna is OpenAI's "fastest and most cost-effective" current model, with "strong performance for focused, high-volume tasks". Think of jobs that repeat many times: sorting support tickets, pulling fields out of documents, tagging content, or short answers inside an app. Per uncached token, Luna costs a twentieth of Sol's price, so it suits work you run thousands of times a day.

Luna supports every effort level from `none` to `max`, with `medium` as the default. At `none` it answers without a reasoning step, which is the fastest option. One limit to know: on Chat Completions, Luna supports function calling only when `reasoning_effort` is `none`. If your app needs tool calls at a higher effort level, use the Responses API.

## Try a different effort level before a different model

Effort sets how much the model reasons before it answers. The Codex docs put it plainly: "Higher effort can improve results for complex tasks, but it takes longer and uses more tokens. Start with the default effort and increase it when the task needs deeper planning or analysis."

So before you move from Sol to Astra, try Sol at `high` or `xhigh`. Before you move from Sol to Luna, try Sol at `low`. In the API you set it with `reasoning.effort` in Responses or `reasoning_effort` in Chat Completions. In Codex, `/model` lets you change the model or its effort level.

## What does each model cost for a real task?

Our GPT prices keep the same steps as OpenAI's list: on our prices too, Astra costs five times Sol per input and output token, and Luna costs a twentieth of Sol per uncached token. The list above shows our price for each model.

Use every model priced per token through the API for 70% less than its official price.

Three rules from OpenAI's pricing, checked on 2026-11-01, change what a real task costs:

- Cached input costs a fraction of the input price: 5% on Sol, 10% on Astra and Luna. In a long conversation or an agent loop, most of the input repeats, so caching decides a large part of the bill.
- A request with more than 272,000 input tokens is billed at twice the input and cache price and 1.5 times the output price, for the whole request. Our prices follow the same long-prompt rule.
- OpenAI bills writing to the cache at 1.25 times the input price.

So compare the cost of a finished task, not the price per token. A model that needs three tries can cost more than one that gets it right the first time, and a long cached session costs less than its raw token count suggests. Each model has its own cache, so switching models in the middle of a task means the next request reads the whole conversation again with no cache hits ([Prompt caching](https://5abeer.ai/en/docs/api/caching.md#gpt)).

If you use GPT models for hours every day, a plan may cost less than paying per token. [AI subscription vs API](https://5abeer.ai/en/guides/ai-subscription-vs-api) compares both routes.

## How to pick a model in Codex

To use Codex with a 5abeer key, add a provider to Codex's config file and keep your key in an environment variable:

`~/.codex/config.toml`

```toml
model = "gpt-6.1-sol"
model_provider = "khabeer"

[model_providers.khabeer]
name = "5abeer"
base_url = "https://api.5abeer.ai/v1"
env_key = "KHABEER_API_KEY"
wire_api = "responses"
```

Codex uses the OpenAI base URL from this list:

| Format | Base URL | Key header |
| --- | --- | --- |
| OpenAI | `https://api.5abeer.ai/v1` | `Authorization: Bearer <KEY>` |
| Anthropic | `https://api.5abeer.ai` | `x-api-key: <KEY>` |
| Gemini | `https://api.5abeer.ai/v1beta` | `x-goog-api-key: <KEY>` |

To change the model, the Codex docs give three ways:

1. `/model` during a session, to switch the model or adjust the effort level
2. `codex --model <model-id>`, or its `-m` alias, when you start Codex
3. `codex exec -m <model-id> "<task>"` for a one-off task without the interactive session

To keep a model for every session, change the `model` value in the config file. A new model may need a recent Codex version, so update Codex if it doesn't recognize a model. The full setup is in [Codex CLI setup](https://5abeer.ai/en/docs/apps/codex.md#manual), and [Codex CLI with an API key](https://5abeer.ai/en/guides/codex-cli-api-key) explains when a key beats a plan.

## Switching models in your own code

On the API, the model is one field in the request. The base URL and the key stay the same for every GPT model, so your code can send routine requests to Luna or Sol and the hardest ones to Astra. Every request is billed by its model and its token count.

OpenAI-compatible: change the base URL and keep your code.

Two details from OpenAI's migration notes matter when you switch:

- Tool calling with Astra and the newer Sol needs the Responses API. Both also work on Chat Completions, but without tool calls.
- When the effort level is not `none`, remove `temperature`, `top_p` and `top_logprobs` from your requests.

The full request format is in [Responses](https://5abeer.ai/en/docs/api/responses.md), and prices for every GPT model are on [OpenAI API](https://5abeer.ai/en/api/openai).

## FAQ

### Which GPT model is best for coding?

For most coding, Sol: OpenAI describes it as close to Astra on complex coding at a fifth of the price per token. For the hardest problems and long multistep agent work, Astra. For small, repeated edits at scale, Luna.

### Is Astra always better than Sol?

No. Astra is stronger on the hardest work, but OpenAI positions Sol close to it on complex tasks. Try Sol at a higher effort level before you pay five times as much per token.

### Is Luna good enough for my app?

It is built for focused, repeated tasks such as classification, extraction and short answers. For long reasoning or large code changes, use Sol. Test both on real samples before you decide.

### What about Terra?

Terra is OpenAI's fast, efficient model for visual reasoning, precise computer use and clear, natural writing. Check the [models page](https://5abeer.ai/en/models) for which Terra versions you can use with 5abeer today.

### Can I switch models in the middle of a conversation?

Yes, with `/model` in Codex or the `model` field in your code. The next request after a switch has no cache hits on the new model, so it costs more. Switch between tasks rather than inside one.

### Does a cheaper model always mean a cheaper task?

Not always. A cheaper model that needs several tries or more fixes can cost more than a stronger one that gets it right the first time. Compare the cost of a finished task, not only the price per token.

## Get started

Comparing GPT with Claude? [Which Claude model to use](https://5abeer.ai/en/guides/which-claude-model) covers Sonnet, Opus and Fable the same way. Or create a key and try the three GPT models on your own tasks.

## Sources

Checked on 2026-11-01:

- OpenAI: [Using the latest model](https://developers.openai.com/api/docs/guides/latest-model)
- OpenAI: [API pricing](https://developers.openai.com/api/docs/pricing)
- Codex docs: [Models](https://developers.openai.com/codex/models)

> 5abeer is an independent service, not affiliated with OpenAI, Anthropic or Google.