GPT Model Selection Guide: Choosing Between Luna, Sol, Terra, and Astra on EXAIV

Most teams adopt a single model ID and never revisit it. The request succeeds, the answer looks fine, and the model stays in place for a year — through a traffic increase, a latency budget, a quality regression, and a cost report that nobody expected. Selecting a model is not a one-time decision; it is a routine engineering choice that should be made from measured behavior on your own workload.

EXAIV exposes a GPT-only catalog. That is a deliberate constraint, and it changes the shape of the decision: you are not choosing between a dozen unrelated vendors. You are choosing among variants of the same model family, where the meaningful differences are cost, latency, output ceiling, and reasoning depth. This guide explains what each tier is for, how to map a task to a tier, and how to run a comparison that produces evidence instead of opinions.

What the tiers actually mean

The catalog groups the GPT models into families whose names are consistent across generations. Learn the family names once and the catalog stays readable as new generations are added.

Suffixes are a separate axis and are easy to misread:

A suffix does not move you to a different tier. gpt-6-astra-ultrafast is still an astra task; it is simply served on a latency-optimized route. Treat tier and suffix as two independent decisions.

The catalog IDs you will actually use

Copy these from the live catalog rather than from memory or from an old ticket. The list below reflects the shape of the EXAIV catalog at the time of writing, and the catalog is the source of truth:

gpt-6-sol
gpt-6-sol-official
gpt-6-astra
gpt-6-astra-official
gpt-6-astra-ultrafast

The suffixes (-official, -ultrafast) mark serving channels rather than capability tiers: an -official ID is the official-channel route, and -ultrafast is a latency-optimized route for the same model. Treat tier and suffix as two independent decisions.

An ID that looks plausible but is not in the catalog will fail at request time with a model-not-found error. The failure is immediate and harmless — but it will not be caught by your configuration validation, because the string is syntactically valid JSON.

Mapping a task to a tier

Start from the task, not from the model. A short decision sequence:

1. What does the output have to get right? If a wrong answer is cheap to detect and cheap to fix — routing, tagging, extraction — the cheapest tier is almost always sufficient.
2. How many reasoning steps does it take? Multi-step problems that need to hold several constraints at once belong on a reasoning tier.
3. How much output do you need? Check the model's output ceiling against your longest realistic prompt. A task that needs a long structured answer can hit a limit on a smaller tier.
4. What is the volume? At high volume, the cheapest passing tier is worth far more than a marginal quality improvement.
5. What is the latency budget? Interactive paths and background paths rarely need the same tier.

A practical default for a new service:

This is a starting point, not a rule. The next section is how to convert it into evidence.

Building an evaluation set worth comparing

The measurement below is only as good as the prompt set behind it. A comparison built from prompts you already know a model will get right produces a confident result and no information.

Build the set from real traffic rather than from imagination:

1. Sample actual requests. Pull a few dozen genuine prompts, redacted where necessary, from your own logs. Real prompts carry the length distribution, the mixed languages, and the malformed input that a synthetic set never reproduces.
2. Write the reference answer. Not a "correct" answer in the abstract — the answer your service would accept. If a human reviewer would sign off on it, it is the reference.
3. Mark a hard subset. Label the prompts where a wrong answer is expensive. A model can average well and still fail badly on the ten percent that matters most.
4. Keep it small. Twenty prompts with clear reference answers beat two hundred with vague ones.

Store the set in version control next to the model ID it was used to judge. When the tier changes, the same set should be re-run, and the diff should be readable by someone who was not present when the decision was made.

Comparing models with a measurement, not a hunch

Build a small fixed evaluation set from your real traffic, then run it across the candidate tiers with identical parameters. Ten to twenty representative prompts are enough to separate tiers; a handful of cherry-picked questions is not.

export EXAIV_API_KEY="YOUR_EXAIV_API_KEY"

curl -sS "https://exaiv.com/api/ai/v1/chat/completions" \
  -H "Authorization: Bearer ${EXAIV_API_KEY}" \
  -H "content-type: application/json" \
  -d '{
    "model": "gpt-6-sol",
    "max_tokens": 512,
    "temperature": 0,
    "messages": [
      {"role": "system", "content": "You classify support tickets. Answer with one label from: billing, outage, other."},
      {"role": "user", "content": "I was charged twice for the same month and the second charge is still on my card."}
    ]
  }'

Three rules make the comparison meaningful:

• Pin temperature to 0 for the comparison. Sampling variance will otherwise blur the difference between tiers.
• Keep the prompt identical across models. Different prompts test different things.
• Score against a reference answer you wrote, not against your impression of which output "looked better".

Then record the three numbers that actually decide the choice:

Cost per successful request matters more than cost per request. A cheaper tier that needs three retries is more expensive than a stronger tier that succeeds on the first attempt.

When to upgrade the tier

Move up a tier when one of these is true:

• the pass rate on your evaluation set misses your quality threshold on the tasks that matter most;
• output is being truncated at the tier's ceiling and the task legitimately needs more;
• the strongest tier measurably improves an outcome your business cares about, and the cost of that improvement is acceptable.

Move down a tier when:

• a cheaper tier matches your pass rate on the evaluation set;
• a task is actually easier than you assumed and nobody inspects the output;
• the work is background processing with no latency requirement.

Planning for cost before you commit

Model selection and cost planning are the same decision viewed from two sides. Because ECAIX bills in credits calculated per token, the arithmetic is short enough to do before deployment rather than after the first invoice.

Take the average input and output token counts from your evaluation run, apply the rates shown in the model directory, and you have a number you can sanity-check against the console.

Three things belong in the estimate that a naive per-request calculation misses:

• Retries. A tier that fails and retries costs more per successful request than per request. Include the failure rate you actually measured.
• Prompt growth. A chat product's prompt usually grows with conversation history. Re-estimate quarterly instead of only at launch.
• Output length. Output tokens are commonly priced above input tokens. A model that writes long answers can cost several times a terse one on identical input.

If a candidate tier fails the quality bar, the right move is usually to fix the prompt or the workflow. Buying a stronger model to compensate for a weak prompt is the most expensive way to solve the problem.

Keeping the choice honest

Record the decision somewhere durable: the model ID, the date, the evaluation set version, and the measured pass rate. Models get updated, prices move, and a catalog refresh can change what sits behind a familiar ID. Without a record, a later "why is this on astra?" question has no answer.

Practical habits that keep selection honest:

• Keep the evaluation set in version control and re-run it when you change tiers.
• Re-check the catalog on a schedule rather than only when a request fails.
• Alert on the pass rate of your own evaluation set, not only on request errors — a quiet quality regression is more expensive than an outage.
• Roll out a tier change to a small percentage first, with the ability to switch the ID back immediately.

Migration is a configuration change

Because EXAIV speaks the OpenAI Chat Completions protocol, changing tiers does not touch your code. You change one string:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_EXAIV_API_KEY",
    base_url="https://exaiv.com/api/ai/v1",
)

response = client.chat.completions.create(
    model="gpt-6-astra",          # the only line that changes
    messages=[{"role": "user", "content": "Explain this traceback..."}],
)

Keep the previous model ID in your configuration so a rollback is a one-line revert, and verify with a single request before moving traffic.

Selection checklist

• The task's quality bar is written down and testable.
• The candidate model IDs were copied from the live catalog, not guessed.
• Every model in the comparison ran the same prompts with temperature set to 0.
• Pass rate, credits per successful request, and p95 latency were all recorded.
• The chosen tier is the cheapest one that clears the quality bar.
• The previous model ID is retained for rollback.
• The decision and its evidence are recorded in version control.

Further reading

• EXAIV model directory — the live catalog is the source of truth for IDs and availability.
• OpenAI SDK Migration Guide — moving an existing application onto the EXAIV endpoint.
• Streaming Responses Guide — handling incremental output correctly in production.

FAQ

Related reading

• Which Qwen Model to Use
• GPT Image Prompt Library
• Model Catalog