Skip to content

GPT-6: choosing Astra, Sol or Luna and setting effort

TechFabricUpdated 8 min read

Ask the OpenAI API for gpt-6.1-sol-high and the request fails with a 400, because reasoning effort isn't part of a GPT-6 model name. In the Responses API it's reasoning.effort, and in Codex CLI it's model_reasoning_effort.

At the milestones on our own repositories, a change gets a review from a model that didn't write it. One of those reviewers is GPT-6.1 Sol at high reasoning effort, run read-only through a small wrapper that pins the model and the effort whoever starts the review. Asking for the suffixed name is the easy mistake, and our review once quietly ran on GPT-6 Sol instead.

That small trap sits on top of the biggest cost decision a team running GPT-6 makes. The model tier and the effort setting decide most of the bill, and a team picks them per workload, so the useful question is how to route work between them.

The GPT-6 family and what changed in the API

GPT-6 is three models: gpt-6-astra for the highest capability, gpt-6.1-sol for complex coding and professional work at a lower cost than Astra, and gpt-6-luna for efficient, repeatable, high-volume work (deployment checklist). The Responses API is now OpenAI's default path, and Astra and GPT-6.1 Sol require it for tool calling.

Three API rules decide whether existing code ports cleanly, and we'd check them before choosing a tier, because the tier you want may need a different API:

Rule What it means for existing code
Effort values are model-dependent: none, minimal, low, medium, high, xhigh, max GPT-6 Sol and Luna take none to max with medium as default; Astra and GPT-6.1 Sol don't support none or minimal (reasoning models, GPT-6 guide)
Chat Completions function calling Only on GPT-6 Sol and Luna, and only with reasoning_effort set to "none"
Sampling parameters Remove temperature and top_p whenever effort isn't none

What the price gap means for a buyer

Astra costs $10.00 per million input tokens and $50.00 per million output tokens at short context, rising to $20.00 and $75.00 at long context. GPT-6.1 Sol is $2.00 and $10.00 at short context, $4.00 and $15.00 long (pricing). GPT-6 Luna is $0.10 in and $0.50 out, half its predecessor's price (Introducing GPT-6 Sol and Luna).

A five-fold gap between Astra and Sol means a workload that runs on the wrong tier can cost five times what it should. Effort compounds it, because effort buys reasoning tokens and reasoning tokens bill as output. So the tier each step runs on, and the effort it runs at, set an AI feature's unit cost, not the vendor. And those choices get remade every time a new workload arrives. A team that sends everything to the best model at high effort pays for a quality margin most of its traffic doesn't need.

An insurer's claims intake across three tiers

Take an insurer that receives a few hundred thousand claim documents a month: invoices, repair estimates, medical bills and the occasional letter that needs a judgement call. The insurer could route by difficulty instead of sending everything to Astra.

Classification and field extraction would go to Luna at low effort. That's the high-volume, repeatable tier OpenAI describes, and at $0.10 per million input tokens it's the only tier where that volume is comfortable:

# Illustrative: the cheap, high-volume tier
response = client.responses.create(
    model="gpt-6-luna",
    reasoning={"effort": "low"},
    input="Classify this document and extract the invoice fields.",
)

A document that fails a validation check, or comes back with low-confidence fields, would escalate to GPT-6.1 Sol at medium effort. Only the exception queue, the claims a person would otherwise read, would reach Astra. That's the one place we'd allow xhigh or max effort, since output at $50 to $75 per million tokens is where a careless setting gets expensive.

Claim documents

Luna at low effort

Validation check

Sol at medium effort

Astra for the exception queue

Claim documents start on Luna at low effort, and only the documents that fail validation climb to Sol and then Astra.

We'd watch the share of documents that leave Luna. It sets the bill more than any price on the table, and when it climbs, the fix is usually the validation check or the extraction prompt rather than a bigger model. We'd read it weekly beside the accuracy of a sample a person reviewed, so a cheaper route never quietly trades away correctness.

The same routing works for any intake that's mostly routine: a lender's income documents, a distributor's supplier invoices, a hospital's referral letters. Most of the volume never needs more than Luna.

How we'd approach a GPT-6 rollout

We'd start with one workload and build the eval before tuning anything. Set the tier you think is right and leave effort at the default medium, because every later decision is a comparison and the eval is the baseline. OpenAI's own migration advice is to keep the current model's role and effective effort, then change one variable at a time. Go from Astra to Sol, or medium to low, but never both in one deploy, or you can't tell which change moved the quality. OpenAI recommends comparing Sol against Astra on your own tasks (model selection), and no benchmark tells you whether Sol is good enough for your contracts.

Next we'd turn on the cost controls that pay immediately. Reused prompt prefixes bill at the cached-input rate, discounted up to 95 percent (prompt caching). The pricing table puts Astra's cached input at $1.00 against $10.00 standard, and Sol's at $0.10 against $2.00. So we'd put system instructions, tool definitions and policy text at the front of every prompt and the variable content last. A prompt that shuffles its order per request pays cache write prices forever. Nightly backfills and evaluations would go to flex processing. It bills at Batch API rates in exchange for slower responses and occasional unavailability, which is wrong for a customer-facing endpoint.

For agent loops we'd give each step of the loop its own tier and effort, the same way as the intake. Planning a multi-step task is worth Sol at medium; calling a lookup tool and formatting its answer is Luna's job. An agent that runs every turn on Astra at high effort is the most expensive way to find out which turns needed it. We'd log tier, effort and outcome per step from the first day, and move steps down once the eval says they hold.

Running GPT-6 from Databricks

When the data already lives in a lakehouse, we'd call GPT-6 through Unity Gateway rather than handing out API keys per notebook. Databricks now calls external model endpoints on Model Serving the legacy approach and points new workloads to model provider services. Those connect to providers such as OpenAI and govern credentials, access, usage and cost with Unity Catalog (external models tutorial). A model provider service is a Unity Catalog securable registered once, so users and services route to it without handling the key (model providers external to Databricks). Creating one needs CREATE SERVICE on the schema plus USE CATALOG and USE SCHEMA (create and manage providers).

You also configure Unity Gateway features such as rate limits and inference tables on a model provider service. We'd set the rate limit before anyone gets access, because one notebook running at max effort can spend real money overnight. We'd keep the inference table on, too, so the escalation share from the routing above can be read from the lakehouse. The identity question is the same one we wrote about in Unity Catalog for AI agents in practice: the identity calling the model and the identity reading the data should be the same governed thing.

Where GPT-6 is the wrong fit

We wouldn't start a GPT-6 migration where the API surface can't change. An integration locked to Chat Completions with tools can't use Astra or GPT-6.1 Sol at all, and gets function calling on Sol and Luna only at reasoning_effort: "none", which turns reasoning off. Moving to Responses is the real first project there.

A tight latency budget is the other mismatch. Higher effort means more reasoning tokens and more time, so a chat widget expected to start streaming in under a second is a low-effort or Luna workload. Prompts tuned for a year with temperature=0.2 also need rewriting against the effort scale, because sampling parameters go once effort is on.

Pick one workload and build the eval first

Choose the workload with the most volume, write its eval, and measure Luna at low effort against your current model before anything else. If Luna holds, most of the saving is already made, and the remaining traffic tells you how much Sol and Astra you actually need.

Frequently asked questions

Which GPT-6 model should I use?

Use gpt-6-astra for the highest capability, gpt-6.1-sol for complex coding and professional work at lower cost, and gpt-6-luna for cost-sensitive, high-volume workloads, per OpenAI's deployment checklist. OpenAI recommends comparing Sol against Astra on your own tasks, and we'd route by difficulty so most traffic runs on the cheaper tiers.

What values does reasoning.effort accept?

Supported values are model-dependent and can include none, minimal, low, medium, high, xhigh and max, with medium the default on GPT-6 Sol and Luna (reasoning models). GPT-6 Astra and GPT-6.1 Sol don't support none or minimal, and effort is never a suffix on the model name.

How much does GPT-6 cost per million tokens?

At short context, gpt-6-astra is $10.00 input and $50.00 output, and gpt-6.1-sol is $2.00 input and $10.00 output; long context is $20.00/$75.00 and $4.00/$15.00 (pricing). Cached input drops to $1.00 and $0.10 respectively, and GPT-6 Luna is $0.10 input and $0.50 output.

Can I call GPT-6 from Databricks?

Yes, by registering OpenAI as a model provider service in Unity Gateway, which stores the credentials as a Unity Catalog securable and governs access, usage and cost (model providers external to Databricks). The older external model endpoints on Model Serving still work, but Databricks describes them as legacy for new workloads.