Moving Off MiniMax M2.5/M2.7 Before Nov 18: Fixing M3.1 Flash's "requires adaptive thinking" 400

MiniMax is retiring M2.5 and M2.7 on 18 November 2026, and the switch has already started. Since 19 October, the two older families have been closed to new users, and plan requests that name them are served by M3.1 Flash. If you're on pay-as-you-go, you have four weeks to change the model ID yourself.

Most M2.7 code runs on M3.1 Flash unchanged. The trouble comes from one design choice: M3.1 Flash always thinks, and it thinks at the deepest level unless you say otherwise. That produces one loud error, some quiet cost increases, and a couple of settings that now do nothing at all.

AIHubMix ran every request in this post through its gateway on 19 October 2026 against minimax-m3.1-flash. Error texts are copied from those responses. MiniMax's rules are quoted from its API docs.

Who is affected, and how

MiniMax's models page puts it this way for plan users: "all requests to M2.5 and M2.7 models under these plans will automatically be routed to M3.1 Flash Preview", and "existing model names will continue to work." For pay-as-you-go users: "Once retired, API requests to these models will no longer work." The notice doesn't mention any automatic redirect for pay-as-you-go, so expect errors rather than a fallback.

Plan users should note what "routed" means. Your logs still say M2.7, but the weights are different, the context is 5× larger, and the thinking depth defaults to max. Treat it as a model change and re-run your evals.

What fails loudly

400: "requires adaptive thinking"

What you'll see. A request that disables thinking is rejected:

{"error": {"message": "invalid params, model \"MiniMax-M3.1-Flash\" requires adaptive thinking; thinking.type=\"disabled\" (including reasoning.effort=none) is not allowed (2013) (tid: …)", "type": "bad_request_error", "param": "", "code": null}}

Why. MiniMax's Messages API reference says the model "always thinks": if thinking.type is sent it must be adaptive, and disabled returns HTTP 400. Code written for M3 can hit it, because M3 lets you turn thinking off. Frameworks that mark the model as non-reasoning and send "thinking off" by default hit it on every call; the kodus-ai and 9router-go projects both reported cases like this.

Minimal request that triggers it (Chat Completions on AIHubMix):

curl https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "minimax-m3.1-flash",
       "messages": [{"role": "user", "content": "hi"}],
       "thinking": {"type": "disabled"}}'

Fix. Delete the thinking field, or set it to {"type": "adaptive"}. If you were disabling thinking to save time, use "reasoning_effort": "low" instead.

400 with the same code 2013 on image URLs

What you'll see. invalid param: remote returned status 400 (2013). We got this from an image URL hosted on upload.wikimedia.org. The same request with a base64 image, or with an image URL from another host, returned 200.

Why. Code 2013 is MiniMax's general "invalid params" code, not a thinking-specific one. Here the upstream apparently couldn't fetch the remote image. That is our reading of the message; MiniMax doesn't document this case.

Fix. Send images as base64 (data:image/png;base64,…), or host them somewhere that serves plain HTTP requests. When you search logs for 2013, read the full message before assuming it's the thinking error.

After 18 November: retired model IDs

Pay-as-you-go calls to MiniMax-M2.5, MiniMax-M2.5-highspeed, MiniMax-M2.7, and MiniMax-M2.7-highspeed on MiniMax's API stop working on that date. M2.1 and M2 aren't in the notice. Change the model ID before then. On AIHubMix the new ID is minimax-m3.1-flash.

What fails quietly

These requests all return 200. The difference shows up in your bill, your latency, or your output.

1. "Thinking off" switches that now do nothing

Through AIHubMix, three ways of asking for no thinking are accepted without an error, and the model thinks anyway:

The first two rows are three runs each on the same three-box logic puzzle, where low used 173–251 reasoning tokens. The minimal check was one run on a one-line arithmetic prompt.

Only Chat Completions with thinking: {"type": "disabled"} produces the 400 above. If your M2.x or M3 code relied on any of these switches to keep calls fast, the calls now silently think. The only real lever is effort, and the lowest level is low.

2. The default effort is max

M2.7 had no thinking levels. M3.1 Flash has five, and MiniMax's docs say omitting the field means max. On a small two-bug fix in one Python function, AIHubMix measured:

Every run at both settings passed all 215 hidden tests. Costs use AIHubMix's prices of $0.165 input and $0.66 output per million tokens, three runs each. If you migrate without adding an effort setting, the same job takes about 6× as long. The full five-level measurement is in the effort post in this series.

3. Thinking eats max_tokens

Thinking tokens count toward max_tokens. M2.x code often sets small limits for short answers. With max_tokens: 64 and a two-sentence question, the model spent the budget thinking, then returned finish_reason: "length" and the answer "Sunlight contains many colors," cut off mid-sentence. MiniMax recommends 131,072 and allows up to 524,288. Raise small limits, or check finish_reason before you trust the text.

4. Caching and service tiers changed

• cache_control is not supported on M3.1 Flash (or M3), per MiniMax's API reference. M2.7 billed explicit cache writes at $0.375 per million. On M3.1 Flash caching is automatic. AIHubMix bills cache reads at $0.0165 per million, and every request we sent had about 175–195 prompt tokens served from cache, even the first one. It looks like a fixed preamble on MiniMax's side; at that price it costs about a third of a cent per thousand requests. Remove cache_control blocks; they do nothing here.
• service_tier is not supported. If you used M3's Priority tier for latency, there is no equivalent on Flash.

5. Same name, different sampling

MiniMax's defaults moved from top_p 0.9 on M2.x to 0.95 on M3.1 Flash, and the context window grew from 204,800 to 1,000,000 tokens. Prompts tuned on M2.7 may produce longer or looser output. A model behind an unchanged name is still a new model: re-run your evals.

Billing rules that are easy to miss

• Thinking is billed as output. On AIHubMix that's $0.66 per million. At the default effort, thinking was 95% of the output on our bug fix (6,364 of 6,673 tokens).
• There's no official per-token price from MiniMax yet. Its pricing page lists M3 and M2.x, not M3.1 Flash. AIHubMix charges $0.165 / $0.66 / $0.0165 (input / output / cache read).
• M3's official price doubles above 512K input tokens. AIHubMix lists a single price for M3.1 Flash. If you send very long prompts, check your first invoice against your own estimate.

Steps that lower the bill:

1. Set reasoning_effort: "low" (Chat), output_config.effort: "low" (Messages), or reasoning.effort: "low" (Responses) as the default, and raise it per task.
2. Keep stable instructions at the start of the prompt so automatic caching can serve them.
3. Set max_tokens large enough that thinking doesn't truncate the answer, because a truncated answer you have to retry costs more than the extra headroom.

Agents with real permissions

Three behaviours matter when the model can run commands or edit files:

• It always reasons before acting, even at low. That helps tool selection. It also means every tool step has thinking latency; on our short tool calls a step took about 2 to 7 seconds at low.
• It does what you say, narrowly. One early tester called it "insanely fast, but it needs clear and specific instructions, otherwise it's too lazy." Give agents explicit stop conditions and verification steps ("run the tests and paste the output") rather than open goals.
• tool_choice is officially auto only. AIHubMix accepted "required" (Chat) and {"type": "any"} (Messages), and the model did call the tool, but MiniMax doesn't document that forcing works. Don't build a safety check on it.

MiniMax says to return thinking blocks unchanged in later turns (Messages) and to keep reasoning_content intact (Chat). A short tool round trip with the thinking block stripped still worked in our test, but follow the documented rule in long agent loops.

Coding tools

AIHubMix serves minimax-m3.1-flash on all three protocols the common coding tools need. Each was tested on 19 October with text, a tool call, and a tool-result round trip.

Context window is 1,000,000 on MiniMax's API. MiniMax Code itself defaults its client to 512K "to balance experience and cost", per a maintainer's quote of MiniMax's docs in the magpie project; the API has no window parameter.

Claude Code. Point it at AIHubMix as in the AIHubMix Claude Code guide, and set the model to minimax-m3.1-flash:

export ANTHROPIC_BASE_URL="https://aihubmix.com"
export ANTHROPIC_AUTH_TOKEN="$AIHUBMIX_API_KEY"
export ANTHROPIC_MODEL="minimax-m3.1-flash"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="minimax-m3.1-flash"   # background tasks too

The two thinking shapes Anthropic-style clients send, enabled with a budget and adaptive, both returned 200 in our tests, so you won't hit the 400. Known issue: it isn't documented whether Claude Code's effort setting reaches a non-Claude model as output_config.effort. If it doesn't, the model runs at its max default, and turns will be slower than with M2.7. The smoke test below shows how to tell.

Codex CLI. Codex talks to the Responses API, which works for this model: function calls come back as function_call items. Configure a custom provider as in the AIHubMix Codex guide, with wire_api = "responses", then set model = "minimax-m3.1-flash" and model_reasoning_effort. xhigh and minimal were both accepted; minimal isn't one of MiniMax's levels, and the model still thinks.

OpenCode. OpenCode issue #54801 (reproduced on v2.0.27) reports that OpenCode resolves no effort variants for this model, so ctrl+t does nothing. The workaround in the issue is to declare the five variants yourself in opencode.json. With AIHubMix's OpenAI-compatible provider, the request field each variant should set is reasoning_effort (low … max) rather than the issue's output_config.effort. Don't add a none variant.

A 15-minute smoke test for any of the three:

1. Create a scratch folder with a function that has one known bug and a test file that fails because of it.
2. Ask the agent: "Run the tests, fix the bug, run the tests again, and show me the output."
3. Success looks like this: the agent runs the tests before and after, the final run passes, it finishes in a few turns, and none of the turns returns a 400.
4. Check the AIHubMix usage log. You should see minimax-m3.1-flash requests with reasoning tokens. If each turn takes close to a minute, your effort setting isn't reaching the model and it's running at max.

Migration checklist

• Replace MiniMax-M2.5 / M2.7 IDs with minimax-m3.1-flash (on AIHubMix) before 18 November.
• Remove thinking disabled, effort none, and effort minimal from requests.
• Add an explicit effort level to every request; start at low.
• Raise max_tokens so thinking can't truncate answers; check finish_reason.
• Remove cache_control and service_tier fields.
• Send images as base64 or from a host the upstream can fetch.
• Keep thinking blocks and reasoning_content intact across tool turns.
• Re-run your evals: same name, new model, new sampling defaults.
• In coding tools, confirm the effort setting reaches the model (turn time is a quick tell).

FAQ

Why do I get "requires adaptive thinking"?
Your request disabled thinking, usually with thinking type disabled on the Chat Completions endpoint. M3.1 Flash always thinks. Remove the field or set it to adaptive, and use effort low if you want speed.

My M2.7 requests didn't change but the answers did. Why?
If you're on a MiniMax M Plan or Token Plan, requests that name M2.5 or M2.7 have been served by M3.1 Flash since 19 October 2026, under the old name.

What's the deadline for pay-as-you-go users?
18 November 2026. After that, MiniMax API requests to M2.5 and M2.7 stop working.

Does reasoning_effort none work on AIHubMix?
It returns 200, but the model still thinks. The lowest effective level is low.

Do I still need cache_control?
No. MiniMax doesn't support it on M3.1 Flash. Caching is automatic, and AIHubMix bills cached input at $0.0165 per million tokens.

Can I use M3.1 Flash in Claude Code and Codex?
Yes. AIHubMix serves it on the Anthropic Messages API for Claude Code and on the Responses API for Codex. Both passed text, tool call, and tool result tests on 19 October 2026.

Why are my answers cut off?
Thinking tokens count toward max_tokens. If finish_reason is length, raise max_tokens. MiniMax recommends 131,072.

Keep reading: the MiniMax M3.1 Flash series

• Before you commit to the switch, see what you're moving to, from the Space Bunny launch to the price against M2.7 and M3: MiniMax M3.1 Flash Is Space Bunny: What Changed from M2.7 and M3, and What It Costs
• The single setting that matters most after migration is effort. This post measures all five levels on one bug fix: MiniMax M3.1 Flash Effort Levels: Why the Default Cost 7× Low on the Same Bug Fix
• If the migration has you reconsidering MiniMax altogether, here are the same task and bill on its two closest rivals: MiniMax M3.1 Flash vs DeepSeek V4.1 Flash vs Claude Haiku 5.5: One Bug Fix, Three Bills

Sources

• MiniMax: Models (retirement notice)
• MiniMax: Messages API reference
• AIHubMix: MiniMax M3.1 Flash
• OpenCode issue #54801: no thinking depth variants for M3.1 Flash
• Developers Digest: MiniMax M2.5 and M2.7 Retirement