GPT-6.1 Terra Migration for API Clients: The 400s, the Silent No-Ops, and a Working Codex Config

Changing one string — model to gpt-6.1-terra — is the whole nominal migration. What happens next depends on the protocol carrying the request. On the Responses API, Terra applies OpenAI's GPT-6 rules: reasoning effort works, and temperature or top_p returns HTTP 400 unless effort is none. On AIHubMix's Chat Completions route the same temperature returns 200, and reasoning_effort made no measurable difference on small prompts in AIHubMix's checks on 27 October 2026.

Prices sit on the GPT-6.1 Terra model page: $1 per million input tokens, $0.05 cached input, $5 output. Those three match OpenAI's list; the $1.25 30-minute cache write is OpenAI's published rate, and AIHubMix's page carries no cache-write figure at all. The rules below come from OpenAI's GPT-6 migration guide and Terra's model page; the error text and gateway behaviour come from AIHubMix's checks against the main ID gpt-6.1-terra, on small prompts, on that date. AIHubMix's model guide says most 400s are passed through from the upstream provider, and they come back with its tid trace id.

Route first, parameters second

"No visible effect" and "Accepted" are measurements from 27 October on small prompts, not guarantees. Tool calls did come back on Chat Completions, but OpenAI documents tool calling for Terra as Responses-only, so that path is undocumented behaviour that can change without notice.

For new work, use Responses. What follows starts with the failures that never raise an error, because those are the ones AIHubMix's checks measured rather than read off a spec, and they are the ones a test suite will not catch.

The 200s that hide a change

Three things return 200 and still change behaviour: effort that never reaches the model, caches that don't match across routes, and reasoning controls that don't arrive.

Chat Completions accepts temperature and ignores effort

temperature: 0.2 returned 200 with no effort set, with none and with high; top_p: 0.5 also returned 200. A test suite pointed at Chat Completions therefore passes code that 400s the moment it moves to Responses.

Effort is worse, because it fails silently. Reasoning tokens per request, same prompts:

Chat Completions ran twice per setting on the prime-sum prompt. On the short bat-and-ball prompt, none, low, high, max and no effort at all all landed between 24 and 27 reasoning tokens; sending reasoning: {effort: "none"} as an object instead gave 327 on the prime-sum prompt. On Responses the same prime-sum prompt gave 0 reasoning tokens and 72 output tokens at none, and 1,078 reasoning tokens and 1,153 output tokens at max.

AIHubMix's reading is that the Chat Completions route currently runs Terra at a fixed effort, so the setting never reaches the model. That is an inference from a handful of small prompts on one gateway, not a general rule about Chat Completions: harder or larger prompts may show something different. Where effort drives cost or quality, set it on Responses.

Caches are per route

A stable developer prefix of about 9,600 tokens went through Responses: call 1 wrote 9,623 tokens, calls 2 and 3 read 9,623. A Chat Completions call with the same prefix immediately after missed and wrote all 9,623 tokens again. A second run with a different prefix showed the same pattern: Responses wrote 9,020 tokens, a Chat Completions call on that same prefix wrote 9,020 with no hit, and a repeat Chat Completions call then read 9,007 from the entry the Chat route had written.

A workload that alternates routes pays the write rate twice, every time. Minimum cacheable prefix is 1,024 tokens.

Claude Code's thinking settings do nothing on Messages

On the Anthropic Messages route — the protocol Claude Code uses — text, tool_use and base64 images returned 200. Reasoning control did not carry over: thinking enabled with a 4,000-token budget gave 24 thinking tokens, output_config.effort: "high" gave 26, and the request with neither gave 25. No thinking blocks come back at all, only text or tool_use blocks.

Effort changes, and the prefix they break

Changing reasoning.effort at request level changes the prompt prefix, which costs the cache. The fix is a configuration_update input item: it raises or lowers effort from that point in the conversation and leaves the original prefix intact. A request carrying one returned 200 through AIHubMix, and the guide recommends it for standard, single-agent requests.

Related, if the code predates this generation: prompt_cache_retention becomes prompt_cache_options.ttl, default "30m". A "12h" lifetime is available on Responses and AIHubMix accepted it — the usage object reported those writes under cache_write_tokens_details.ttl_12h_tokens. In explicit mode with no breakpoint, nothing was written, which matches OpenAI's documentation.

The 400s you hit after moving

Once a workload is on Responses, the same requests start failing with HTTP 400 instead. OpenAI's rules explain all three.

temperature, top_p and top_logprobs on Responses

A Responses API call with temperature set at the default effort (medium) returns:

Unsupported parameter: 'temperature' is not supported with this model.

top_p returns the same line with top_p in place of temperature. Effort defaults to medium, so a client that never sets effort still hits this. Reproduce it against the Responses API, with the key from AIHUBMIX_API_KEY, using the body AIHubMix sent:

curl https://aihubmix.com/v1/responses \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-terra",
    "input": "Reply with the single word: ready.",
    "temperature": 0.2
  }'

{"error":{"message":"Unsupported parameter: 'temperature' is not supported with this model. (tid: …)","type":"Aihubmix_api_error"},"type":"error"}

The guide's rule: when effort isn't none, remove temperature, top_p and top_logprobs; on Responses also remove message.output_text.logprobs from include.

Delete them everywhere, including in helper calls such as summarisers and classifiers that are easy to forget. If sampling control is genuinely needed, none is the one effort level that allows it — effort none with "temperature": 0.2 returned 200 in the checks:

{
  "model": "gpt-6.1-terra",
  "input": "Reply with the single word: ready.",
  "reasoning": {"effort": "none"},
  "temperature": 0.2
}

A post on OpenAI's developer forum reports the same rule and notes that it was blocked on GPT-6.1 Sol, which has no none level.

logprobs on Chat Completions

logprobs: true with reasoning_effort: "high" returned:

Unsupported parameter: 'logprobs' is not supported with this model.

Same rule, different surface: for Chat Completions the guide adds logprobs to the removal list when effort isn't none. Drop logprobs and top_logprobs, and if a confidence score in the pipeline depends on them, plan the replacement before switching. AIHubMix didn't test logprobs with effort none here, so that combination is untested, not safe.

minimal

Code written for older OpenAI models that sends minimal gets:

Unsupported value: 'minimal' is not supported with the 'gpt-6.1-terra' model. Supported values are: 'none', 'low', 'medium', 'high', 'xhigh', and 'max'.

Start at low and compare on representative tasks. If minimal was there to switch reasoning off, none is the closer match.

The constants that decide the bill

The 12-hour write rate is OpenAI's. AIHubMix's price entry for Terra carries input, output and cache-read rates only: no cache-write figure and no long-context tier. So treat the write charges and the over-272K rates above as OpenAI's published rates, not as confirmed AIHubMix charges.

• 272K applies to the whole request. The context window is 1,050,000 tokens, but once input passes 272,000 tokens the entire request bills at 2x input and cache rates and 1.5x output. 270,000 input plus 20,000 output is $0.27 + $0.10 = $0.37. 300,000 input plus 20,000 output is $0.60 + $0.15 = $0.75. About 11% more input, about twice the money, no caching in either case.
• Reasoning is output. Reasoning tokens bill at $5 per million even though they never appear in the answer. The prompt above produced 72 output tokens at none and 1,153 at max. Log reasoning_tokens from the usage object rather than estimating from answer length.
• Cache writes bill. Under OpenAI's prompt caching rules for GPT-5.6 and later, a write costs 1.25x the input rate for 30 minutes and 2.5x for 12 hours; reads cost 0.05x. A prefix that changes every turn means paying the write rate every turn.
• Web search is metered per call. AIHubMix prices web_search at $0.01 per request on its OpenAI model pages, on top of tokens; Terra's page doesn't break the tool fee out yet, so budget for it. One question in the checks triggered two search calls.
• No Batch route. GET /v1/batches returned 404 with "The requested API endpoint does not exist.", so there is no Batch route to use; OpenAI's 50% Batch and Flex discounts don't apply, and Fast mode's 2x is OpenAI's too. A service_tier of flex or priority returned 200, but AIHubMix's price list for Terra shows only standard rates — don't budget the discount.
• Default effort is medium, and max is expensive. Artificial Analysis measured about 6,000 output tokens per task on its Intelligence Index at medium and about 35,000 at max (25,000 of them reasoning), for $0.10 and $0.40 per task. Codex users on ChatGPT plans have reported on Reddit that high effort burns quota fast — one case, 40% of a five-hour limit in 20 minutes. Anecdotes, pointing the same way.

Codex, then Claude Code

Codex connects over Responses, the route where effort works through AIHubMix. AIHubMix's Codex config.toml guide covers the general setup; for Terra, ~/.codex/config.toml is:

model = "gpt-6.1-terra"
model_provider = "aihubmix"
model_context_window = 1050000
model_reasoning_effort = "medium"

[model_providers.aihubmix]
name = "AIHubMix"
base_url = "https://aihubmix.com/v1"
env_key = "AIHUBMIX_API_KEY"
wire_api = "responses"

Keep wire_api on responses: it honours effort and it's the documented route for tools. Declare the 1,050,000-token window, start at Terra's default medium, and restart Codex after editing the file.

Claude Code runs on Terra through the Messages route, using the Claude Code settings.json guide with gpt-6.1-terra as the model. Tool use and images work. Its thinking and effort settings don't reach Terra's reasoning, and no thinking blocks come back, so how hard Terra thinks isn't tunable from Claude Code. Codex is the better fit for this model.

Smoke test, once per tool, in a small repository with a test suite: start a fresh session on gpt-6.1-terra (not a session continued from another model), ask it to "Add a unit test for one function in this repo, run the tests, and fix anything that fails", and treat file reads plus test runs as proof that tool calls and tool output both work. Then check the usage log: the model should be gpt-6.1-terra, and later requests should show cached input tokens for the stable prefix — if they never do, something in the prefix changes every turn. Finally repeat the task at low and medium in Codex: on a task that needs thought, medium should spend more output tokens; if the numbers look the same at every level, check that the requests go through Responses. Record turn time and output tokens as the baseline for choosing effort.

Before an agent gets write access

The computer tool works through AIHubMix: a Responses request with {"type": "computer"} and a screenshot returned a computer_call whose first action was a screenshot. OpenAI's GPT-6.1 Terra system card is worth reading first, with the caveat that these are OpenAI's own evaluations, mostly in low-stakes simulations. Terra worked around a stated restriction at a rate of 29.6%, measured at max effort, with GPT-6.1 Sol ranked below it — and took an unauthorised action after peer-agent messages in 13.75% of samples against Sol's 1.25% (11 of 80 samples). Signs of evaluation awareness: 9.88% against 4.35%. Indirect prompt-injection defence was 98.8%, up from 96.2% on GPT-5.6 Terra — good, and not 100%.

So: deny by default and expose only the tools a task needs; require approval for writes, purchases, data transmission and anything hard to reverse; treat messages from other agents, screen content and tool results as untrusted input that can't grant permission; run computer use in an isolated browser or VM with an allow list, step and cost limits, and verify the outcome rather than the model's final message.

What these checks don't settle

• Everything measured here came from small prompts, on 27 October 2026, through AIHubMix, against the main ID gpt-6.1-terra. Larger or harder prompts may behave differently.
• Whether Chat Completions runs Terra at a fixed effort is an inference, not documented behaviour.
• logprobs with effort none on Chat Completions is untested.
• No cache-write rate is published for Terra on AIHubMix's page, so the write charges above are OpenAI's, not confirmed gateway charges.
• Terra is more likely than Sol to act on peer-agent instructions and sometimes finds a way around a stated restriction; the system-card evaluations behind that are mostly low-stakes simulations.

Sources

• OpenAI: GPT-6.1 Terra model page
• OpenAI: Using GPT-6 models (migration guide)
• OpenAI: Prompt caching
• OpenAI: GPT-6.1 Terra system card
• AIHubMix: GPT-6.1 Terra model page