GPT-6 Astra API: One Model String, Two Things You Cannot Set

The GPT-6 Astra API is reached with a model string and nothing else unusual — `gpt-6-astra`, the same identifier on the vendor's documentation card and in our catalog, read 2026-10-07. GPT-6 Astra is carried here at list rate with no markup, so an integration test costs whatever the tokens cost and nothing more.

The interesting part of the integration is not the string. It is the two things the model will not let you configure, one of which is easy to miss until a batch has already run.

The model string, and one trap in it

The identifier is `gpt-6-astra`. Its sibling is `gpt-6.1-sol`. Read those two side by side and the family's naming is visible, and so is the trap.

One of them carries a minor-version dot in the middle of the version and the other does not. `gpt-6.1-sol` has a dot; `gpt-6-astra` does not, because Astra is a new name in the line rather than a version bump of an existing one — the independent record's deprecation chains list replacements such as `gpt-6-sol` → `gpt-6.1-sol` and carry no entry for Astra, which is what a fresh product name looks like rather than a successor to a specific model.

That matters to code, not to prose. If any part of your stack builds model identifiers from a template — a config generator, a routing table keyed on a version number, a test that asserts a regex like `^gpt-\d+\.\d+` — Astra will not match it, and the failure will look like a routing bug rather than a naming one. The fix is one line: treat the model string as an opaque constant, never as something to assemble. Check where your identifiers come from before you check anything else.

The ladder starts at low, not at none

Astra's reasoning settings run from low to max. There is no `none` rung.

Some reasoning models in this generation let you switch reasoning off entirely — both by choosing a `none` level and, on some APIs, by omitting the effort parameter, which is commonly treated as the same thing. On Astra the ladder is bounded at the bottom: the cheapest setting the model offers is still a reasoning setting.

That has a visible consequence for cost and latency. A call that would have been effectively free of reasoning tokens on a model with a `none` rung will generate some here, and reasoning tokens are billed as output at $50 per million. For an extraction or classification endpoint that was relying on "no reasoning" to keep calls cheap and fast, that change is a real regression in unit economics — not a large one, but a permanent one, and it will not show up in a unit test that only checks the answer's shape.

The effort setting also changes what the numbers mean. Every performance figure for this model on the independent harness is measured at Max, the top rung (read 2026-10-07), which is the expensive configuration. A benchmark comparison that stacks four models without naming their effort rungs is comparing configurations rather than models — Grok 4.7, in the same comparison set, is measured one rung down at Xhigh.

Temperature, top_p and logprobs are not yours to set

This is the restriction that catches the most integrations, and it is the one worth reading twice.

Astra is served with fixed sampling: temperature, top_p and logprobs are not exposed as adjustable parameters.

Everything you would normally do with those three has to move somewhere else.

What that removes, concretely:

• Temperature-scaled variety. No 0.2 for extraction and 0.9 for brainstorming off the same route — the setting is not available to vary.
• Multi-sample voting. The pattern of firing the same prompt at several temperatures and taking the majority is not available, because there is only one temperature. Self-consistency schemes need redesigning, usually as repeated calls at the same setting or as an ensemble across different models.
• Explicit determinism. A temperature of 0 is a common way to ask for the same answer twice. Without the parameter there is no such knob, and reproducibility has to come from your own harness rather than from a setting.
• Token-level confidence. `logprobs` is how a pipeline gets a per-token probability for thresholds, filtering or a confidence score. There is no substitute for it at the API level; if a downstream step consumes those numbers, that step has to be rebuilt.
• A quick eval during migration. Teams often differentiate options by varying temperature. Here the differences surface at the effort rung instead, which changes the volume of reasoning tokens as well as the answer.

Both restrictions — the missing `none` rung and the fixed sampling — belong to the model rather than to any particular route, and the specification sheet does not advertise either of them. They are the kind of detail found by reading the documentation carefully rather than by scanning the price table, and the practical advice is the same in both cases: run one probe call with your exact production parameters before a migration is scheduled, not during it.

Whether an unsupported parameter is rejected with an error or quietly ignored is the difference between a failed request and a silently different answer, and the only way to know which you are getting is to send one and look at what comes back.

The rest of the migration checklist

The two restrictions above are the Astra-specific ones. Four other items are shared with the rest of the line and still belong on the list.

Token ceilings. The maximum output is 128K tokens, and the advertised input window is 1.05M. Any hard-coded `max_tokens` above the ceiling is a request that will not do what you intended, and any prompt-assembly step that concatenates retrieved documents without a bound is one that will eventually exceed the window on a real document rather than a test one.

The long-input band. On OrcaRouter's own rate card, requests above 272,000 input tokens are billed at a higher tier — $20 in and $75 out for this model, rather than $10 and $50. That band is our line rather than a row from the vendor's published card, and it makes a p95 input length a budget input rather than a curiosity. If your routes habitually assemble large contexts, measure the p95 before committing to the flagship rung.

Caching, if the prefix is stable. Cache reads on this model are $1 per million tokens against $10 for fresh input, and a write costs $12.50. A route with a fixed system prompt or a fixed tool schema is leaving an order of magnitude on the table if the prefix is not being reused — but the wiring has to be deliberate, and a prefix that changes on every call is not a cache candidate at all.

One place for the model string. If the identifier appears in more than one service, the migration is not a model change; it is a coordinated deploy. Deciding which it is takes about ten minutes with a code search and saves an incident.

Testing it in an afternoon

An integration test worth running before the first production route, in this order.

Send one call with your exact production parameters and read the raw response for any parameter the API declined to accept — do not infer it from the answer's quality. Then send the same prompt twice at the same setting and compare the outputs; without a temperature knob this tells you what your reproducibility actually rests on. Then measure the reasoning tokens on your cheapest route to see what the missing `none` rung costs you in practice. Then check the answer's length against the 128K ceiling with the longest document you genuinely have.

And finally, price the same call with and without a cached prefix, which is the one number most likely to change the architecture rather than the configuration.

Five probes, one afternoon, and every one of them is a fact about your traffic rather than about the model.

The takeaway

The GPT-6 Astra API is a model string and a ladder, and the two details that decide an integration are restrictions rather than features: the reasoning ladder starts at low with no `none` rung, and temperature, top_p and logprobs are not exposed, so temperature-scaled variety, multi-sample voting, explicit determinism and token-level confidence all have to move out of the request. Add the 128K output ceiling, the 272K input band on our rate card, and the model string's inconsistent version dot, and the migration is a checklist rather than a swap.

None of those is a reason to avoid the model. All of them are reasons to send one probe call before scheduling the deploy rather than discovering them in production — and each takes minutes to check against a real endpoint.

OrcaRouter carries GPT-6 Astra at list rate on the same key as the rest of the OpenAI line, so a probe costs the tokens it uses and changing a route back is a one-line edit rather than a procurement cycle.