Migrating to GPT-6.1 Terra: Fix the temperature 400s, Move Tools to Responses, and Set Up Codex

Switching to GPT-6.1 Terra is a one-line change: set the model to gpt-6.1-terra. What happens next depends on which API route the request takes. On the Responses API, Terra follows OpenAI's rules: reasoning effort works, and temperature or top_p return HTTP 400. On AIHubMix's Chat Completions route, the same temperature is accepted without complaint, and in AIHubMix's checks on 27 October 2026, reasoning_effort made no measurable difference on small prompts.

So the short answer for most teams: move Terra traffic to the Responses API, remove the sampling parameters, and keep each workload on one route. Below: the errors you'll see, the problems that raise no error, the billing rules that catch people out, agent permissions, and Codex and Claude Code setup. Terra is on AIHubMix's GPT-6.1 Terra model page, at OpenAI's list price: $1 per million input tokens, $0.05 cached, $1.25 for a 30-minute cache write, and $5 output. AIHubMix's own page lists the same input, output and cache-read rates, but no cache-write rate.

The rules come from OpenAI's GPT-6 migration guide and Terra's model page. The error texts and gateway behaviour come from AIHubMix's checks on 27 October 2026, which used small prompts against the main ID gpt-6.1-terra. AIHubMix's model guide says most 400s are passed through from the upstream provider, and these come back with its tid trace id in the message.

Which route are you on?

AIHubMix served Terra on three protocols in those checks. They don't behave the same way:

"No visible effect" and "Accepted" describe what AIHubMix measured on 27 October, on small prompts. Tool calling on Chat Completions returned tool calls, but OpenAI documents tool calling for Terra as Responses-only.

If you're starting fresh, use Responses. If a Chat Completions integration works today, read the quiet failures before trusting it.

The loud failures

These return HTTP 400 and stop the request.

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

What you'll see. A Responses API call with temperature set and the default effort (medium) returns:

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

Sending top_p returns the same error with top_p in place of temperature. Effort defaults to medium, so a request that never sets effort still hits this.

Why. OpenAI's migration guide says that when reasoning effort isn't none, you must remove temperature, top_p and top_logprobs. On Responses, also remove message.output_text.logprobs from include.

Reproduce it. This curl call through the AIHubMix Responses API sends the same body AIHubMix sent on 27 October:

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
  }'

It came back with HTTP 400:

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

Fix. Delete temperature and top_p from every call path, including helper calls such as summarisers and classifiers that you may have forgotten about. If you need sampling control, set effort to none: Terra supports it, and a request with effort none and "temperature": 0.2 returned 200 in AIHubMix's checks. 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.

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

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

What you'll see. A Chat Completions call with logprobs: true and reasoning_effort: "high" returned:

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

Why. It's the same OpenAI rule. For Chat Completions, the guide adds logprobs to the list of parameters to remove when effort isn't none.

Fix. Remove logprobs and top_logprobs. If a confidence score in your pipeline depends on them, plan a replacement before switching. AIHubMix didn't test logprobs with effort none on Chat Completions.

"Unsupported value: 'minimal' is not supported…"

What you'll see. Code written for older OpenAI models that sends minimal effort gets:

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

Why. Terra's effort levels are none, low, medium, high, xhigh and max. There is no minimal.

Fix. OpenAI's guide says to start with low and compare results on representative tasks. If the old setting was chosen to switch reasoning off, none is the closer match.

The quiet failures

These return HTTP 200, so nothing in your logs flags them. They show up later as answers that don't match your settings, missed cache hits, or an agent that stops to ask questions.

Chat Completions accepts temperature and seems to ignore effort

On AIHubMix's Chat Completions route, temperature: 0.2 returned 200 with no effort set, with effort none and with effort high. top_p: 0.5 also returned 200. That has a side effect: if your test suite runs on Chat Completions, it won't catch the 400 that the same code will hit after you move to Responses.

Effort is the bigger issue. In AIHubMix's checks on 27 October, reasoning_effort on Chat Completions made no measurable difference:

Figures are reasoning tokens per request. 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 gave 24 to 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 produced 0 reasoning tokens and 72 output tokens at none, and 1,078 reasoning tokens and 1,153 output tokens at max.

AIHubMix's reading of this is that the Chat Completions route currently runs Terra at a fixed effort, so the setting doesn't reach the model. That's an inference from a handful of small prompts, measured on AIHubMix only, not a general rule about Chat Completions. Larger or harder prompts might show something different. If effort matters to your cost or quality, set it on Responses, where it clearly works.

Tool calls on Chat Completions work, but aren't documented

OpenAI's guide says that GPT-6.1 Terra supports Chat Completions, but tool calling requires Responses. On AIHubMix, a Chat Completions request with a function tool did come back with finish_reason: tool_calls. Don't build on that: it's undocumented behaviour that could change without notice. On Responses, a function tool returned a function_call item, web_search returned search calls and a message, and a function tool with async: true also returned 200. Move tool traffic to Responses.

Claude Code's thinking settings do nothing on the Messages route

AIHubMix also answers Terra on the Anthropic Messages API, the protocol Claude Code uses. Text, tool_use and base64 images all returned 200. Reasoning control didn't 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 in the response, only text or tool_use blocks.

Responses and Chat Completions keep separate caches

AIHubMix sent a stable developer prefix of about 9,600 tokens through Responses. Call 1 wrote 9,623 tokens to the cache, and calls 2 and 3 read 9,623 cached tokens. A Chat Completions call with the same prefix straight after got no hit and wrote all 9,623 tokens again. A second run with a different prefix repeated the pattern: the Responses call wrote 9,020 tokens, a Chat Completions call on the same prefix wrote 9,020 with no hit, and a repeat Chat Completions call read 9,007 from the entry the Chat route had written.

So a workload that alternates between routes pays for every cache write twice. Pick one route per workload.

Cache settings from older models

If you're coming from GPT-5.5 or earlier, OpenAI's guide says to replace prompt_cache_retention with prompt_cache_options.ttl. The default is "30m". A "12h" lifetime is available on Responses, and AIHubMix accepted it: the usage object reported the writes under cache_write_tokens_details.ttl_12h_tokens. In explicit mode with no breakpoint, nothing was written, which matches OpenAI's documentation.

Changing effort mid-conversation

Changing reasoning.effort at the request level changes the prompt prefix, which costs you the cache. OpenAI added a configuration_update input item for this. 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. OpenAI's guide recommends it for standard, single-agent requests.

The model asks before it acts

OpenAI's GPT-6 prompting notes say the family is more likely to stop and ask the user a question when more input could change the result, and more sensitive to instructions in skills and files such as AGENTS.md. Those notes were written for GPT-6 Astra, so they're worth checking on Terra rather than taking as given. If an agent that ran unattended on GPT-5.6 Terra now pauses for approval, the guide's fix is to state in the prompt what the user's request already authorises. It also recommends auditing every skill and instruction file the model can read.

Effort defaults to medium, and max costs much more

Terra's default effort is medium. 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. If you raise effort to fix a quality problem, check what it does to the bill first. Codex users on ChatGPT plans have reported on Reddit that Terra at high effort uses up plan limits fast, in one case 40% of a five-hour limit in 20 minutes. Those are anecdotes, but they point the same way.

Billing traps

Terra's input, output and cache-read rates are the same on AIHubMix as on OpenAI. These are the rules that make a bill larger than the list price suggests.

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, no long-context tier and no 12-hour premium. So treat the write charges and the over-272K rates above as OpenAI's published rates, not as confirmed AIHubMix charges.

The 272K line applies to the whole request. Terra's model page lists a 1,050,000-token context window, but once input passes 272,000 tokens, the whole request is billed at 2x the input and cache rates and 1.5x the output rate. A request with 270,000 input and 20,000 output tokens costs $0.27 + $0.10 = $0.37. One with 300,000 input and 20,000 output costs $0.60 + $0.15 = $0.75. About 11% more input costs about twice as much (no caching in either example).

Reasoning bills as output. Reasoning tokens count as output tokens at $5 per million, even though you never see them. In AIHubMix's check above, the same prompt produced 72 output tokens at none and 1,153 at max. Log reasoning_tokens from the usage object instead of estimating cost from the length of the answer.

Cache writes are billed. Under OpenAI's prompt caching rules for GPT-5.6 and later, a write costs 1.25x the input rate for the 30-minute lifetime and 2.5x for 12 hours. Reads cost 0.05x on Terra. The minimum cacheable prefix is 1,024 tokens. A prefix that changes every turn, or traffic split across two routes, means paying the write rate again and again.

Web search is charged 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. In one check, a single question triggered two search calls.

Batch and Flex discounts are OpenAI's. OpenAI offers 50% off through Batch and Flex, and Fast mode at 2x. AIHubMix returned 404 for GET /v1/batches ("The requested API endpoint does not exist."), so there is no Batch route to use there. A service_tier of flex or priority returned 200, but AIHubMix's price list for Terra shows only the standard rates, so don't plan on a discount. Check your usage log if you send either.

Agents with real permissions

OpenAI pitches Terra at visual reasoning and computer use, and the built-in computer tool works through AIHubMix: a Responses request with {"type": "computer"} and a screenshot returned a computer_call whose first action was a screenshot. Before an agent gets write access, read the agent results in OpenAI's GPT-6.1 Terra system card. They're OpenAI's own evaluations, mostly in low-stakes simulations:

Terra's workaround rate was measured at max effort; the system card ranks GPT-6.1 Sol below it. The peer-agent figure is 11 of 80 samples.

On indirect prompt injection, Terra's defence rate was 98.8%, up from 96.2% for GPT-5.6 Terra. That's good, and still not 100%. Two results matter most for a migration: Terra is more likely than Sol to act on instructions that arrive from another agent, and it sometimes finds a way around a restriction stated in its instructions. So:

• Give tools deny-by-default permissions, and expose only what the task needs.
• Require approval for writes, purchases, data transmission and anything hard to reverse.
• Treat messages from other agents, like 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, set step and cost limits, and check the actual outcome rather than the model's final message. These are OpenAI's computer-use recommendations.

Coding tools: Codex and Claude Code

Codex (recommended for Terra)

Codex connects over the Responses API, the route where Terra's effort setting works through AIHubMix. AIHubMix's Codex config.toml guide covers the general setup. For Terra, ~/.codex/config.toml looks like this:

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's the route that honours effort and the one OpenAI documents for tools.
• Declare the context window. Set model_context_window to Terra's 1,050,000 tokens.
• Start at medium. It's Terra's default. Raise effort for a hard task rather than globally, given the quota reports above.
• Restart after edits. Restart Codex after changing config.toml.

Claude Code

Claude Code works with Terra through AIHubMix's Messages route. Set it up with the Claude Code settings.json guide, using gpt-6.1-terra as the model. Tool use and images worked in AIHubMix's checks. But Claude Code's thinking and effort settings had no effect on Terra's reasoning there, and no thinking blocks come back. You can't tune how hard Terra thinks from Claude Code, so Codex is the better fit for Terra.

A 10-15 minute smoke test

Run this once per tool, in a small repository with a test suite:

1. Start a fresh session on gpt-6.1-terra. Don't continue a session that ran on another model.
2. Ask: "Add a unit test for one function in this repo, run the tests, and fix anything that fails."
3. Success looks like this: the model reads files and runs the tests, so tool calls work. It carries on after seeing the results, so tool output is being passed back. It ends with passing tests and no 400 anywhere in the session.
4. In your AIHubMix usage log, check that the model is gpt-6.1-terra and that later requests show cached input tokens for the stable prefix. If they never do, something in the prefix changes every turn.
5. In Codex, repeat the task at low and at medium and compare output tokens per turn. On a task that needs some thought, medium should use more. If the numbers look the same at every level, check that the requests go through Responses.
6. Note the turn time and output tokens. They're your baseline for choosing an effort level.

Migration checklist

• Set the model to gpt-6.1-terra.
• Move tool calls, and anything that depends on effort, to the Responses API.
• Remove temperature, top_p, top_logprobs and logprobs from every call path, or set effort to none.
• Replace minimal effort with low.
• Keep each workload on one route so its cache isn't written twice.
• Replace prompt_cache_retention with prompt_cache_options.ttl.
• Use configuration_update to change effort mid-conversation.
• Keep requests under 272K input tokens where you can.
• Log reasoning tokens, cached tokens and cache-write tokens.
• Budget for web search at $0.01 per call, and don't plan on Batch through AIHubMix.
• Audit AGENTS.md and skill files, and state what the agent is authorised to do.
• Put approvals on writes and treat peer-agent messages as untrusted.
• Run the smoke test in each coding tool.

FAQ

Why does GPT-6.1 Terra return "Unsupported parameter: 'temperature'"?
Because reasoning effort isn't none. OpenAI's rule for the GPT-6 family is that temperature, top_p and top_logprobs must be removed when effort is anything other than none, and Terra defaults to medium. Remove them, or set effort to none if you need sampling control.

Why does the same code work on Chat Completions?
AIHubMix's Chat Completions route accepted temperature 0.2 and top_p 0.5 with a 200 in the checks on 27 October 2026. That means tests on Chat Completions won't catch the 400 that the Responses API returns.

Does reasoning_effort work on Chat Completions through AIHubMix?
It made no measurable difference in AIHubMix's checks on 27 October 2026, on a few small prompts: none and max gave similar reasoning-token counts. That isn't a general rule, but if effort matters to you, set it on the Responses API, where it clearly works.

Do I have to move tool calls to the Responses API?
Yes. OpenAI documents tool calling for Terra as requiring Responses. A Chat Completions request with a function tool did return tool calls through AIHubMix, but that's undocumented behaviour and shouldn't be relied on.

What replaces minimal effort?
Terra supports none, low, medium, high, xhigh and max. OpenAI suggests starting with low and comparing results on representative tasks.

Is Batch available for Terra on AIHubMix?
No. A GET /v1/batches call returns 404 on AIHubMix, so there is no Batch route to use; the 50% Batch and Flex discounts are OpenAI's. AIHubMix's price list for Terra shows standard input, output and cache-read rates, which match OpenAI's list price.

Should I use Codex or Claude Code with Terra?
Codex. It uses the Responses API, where Terra's effort setting works through AIHubMix. Claude Code works over the Messages route, but its thinking and effort settings had no effect on Terra in AIHubMix's checks.

Keep reading: the GPT-6.1 Terra series

• If you haven't decided whether the switch from GPT-5.6 Terra is worth it, start with what changed and who gains: GPT-6.1 Terra vs GPT-5.6 Terra: Half the Price, What Changed, and Who Should Switch
• If your migration is for a screen or document agent and you're weighing Anthropic's mid tier, here is the head-to-head: GPT-6.1 Terra vs Claude Sonnet 5.5: Which Mid-Tier Model for Screen and Document Agents?
• If the agent results above give you pause, or your hard coding tasks still need the bigger model, this post sorts the work between the two: GPT-6.1 Terra vs GPT-6.1 Sol: Which Tasks Still Need Sol?
• If the billing traps here have you checking your own numbers, the full cost breakdown covers effort, the 272K line and caching with worked examples: What GPT-6.1 Terra Really Costs: Effort Levels, the 272K Line, and Caching

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