MiniMax M3.1 Flash Effort Levels: Why the Default Cost 7× Low on the Same Bug Fix

MiniMax M3.1 Flash has five thinking levels and no off switch. If you don't pick a level, the model picks the deepest one for you. MiniMax's text generation guide says effort "defaults to max when omitted."

That default is expensive in a way that's easy to miss. AIHubMix ran the same two-bug fix at every level. The default used about 10× the thinking tokens of low and took about 6× as long, and every run at every level passed all 215 tests. The model's thinking cost rose with the effort setting, while the task's difficulty stayed the same.

The short answer: start at low, move up only when a task fails or retries, and never leave the field empty.

Five levels, no off switch

Thinking can't be disabled. Per MiniMax's Messages API reference, the API returns HTTP 400 for thinking: {"type": "disabled"} and for effort none, with the message model "MiniMax-M3.1-Flash" requires adaptive thinking. Older MiniMax models ignore the effort field entirely. M3.1 Flash is the only MiniMax model so far where it does anything.

All three protocols are available for minimax-m3.1-flash on AIHubMix. One difference from MiniMax's own API: AIHubMix accepted reasoning_effort: "none" and "minimal" with HTTP 200, and the model thought anyway. Treat those values as no-ops, not as a way to switch thinking off.

What each level cost on one task

The test: a billing function with two bugs. A pause that runs past the end of the period double-counts a day, and overlapping pauses are subtracted twice. The model returns the fixed function, and a local harness checks it against 215 hidden cases. Each level ran three times through AIHubMix's Chat Completions endpoint on 19 October 2026, with max_tokens at 32,768. All figures were measured by AIHubMix, and nobody else has reproduced them.

Costs use AIHubMix's prices for minimax-m3.1-flash: $0.165 per million input tokens, $0.66 per million output tokens, and $0.0165 per million cached input tokens. Thinking tokens are billed as output. For example, the "omitted" row averaged 464 prompt tokens (about 192 cached) and 6,673 output tokens, which comes to about $0.0045 per fix.

What the numbers say

Low was enough for this task. Every level produced a correct fix every time. On a bounded, single-function bug, the extra thinking at higher levels bought nothing measurable.

Low to medium is a clear step. Medium averaged about 2.6× the thinking tokens of low and more than twice the time.

Above medium, the levels blur. Our xhigh runs averaged fewer tokens than high, and max overlapped with both. Three runs per level can't separate them. On this task, "high", "xhigh", and "max" were all "more thinking, sometimes a lot more."

Omitted behaves like max. That matches MiniMax's docs. Our "omitted" average came out higher than "max", but the ranges overlap and the difference is within run-to-run noise.

Variance is large at every level. The default ranged from 39 to 82 seconds for the same prompt. On the Anthropic Messages endpoint, three low runs used 511, 1,861, and 6,060 thinking tokens. The last one took 56 seconds, as long as a typical max run. Effort sets the average depth of thinking, not a hard cap on it.

Throughput was steady, about 112 output tokens per second across all 24 Flash runs, so time scales almost linearly with thinking tokens. At this speed, a 6,000-token think means a wait of almost a minute.

MiniMax hasn't published its own per-level token or latency data. When a harder task starts to need the higher levels, we can't say from this one test. The numbers above only show what each level costs when the task doesn't need it.

Short prompts barely think

"Always thinks" doesn't mean "always thinks a lot." Thinking is adaptive, so depth follows how hard the prompt looks:

• Classifying five support tickets into one of four labels: 0 thinking tokens at low and an average of 6 at the default. Every label was correct.
• "What is 17 × 23?" at low: no thinking at all, 2 output tokens.

So the missing off switch costs almost nothing on short classification, extraction, and routing calls. The cost shows up on open-ended tasks like code, where the model finds more to think about the deeper you let it go.

Where to start

These are starting points. Only the first two rows were measured directly; the rest are our recommendations, to check against your own retries:

Use max only when you've seen high fail on that kind of task.

What breaks or gets expensive when effort changes

• Truncated answers. Thinking counts toward max_tokens. One default run used 9,376 thinking tokens on a single function, so a 4K or 8K limit set for M2.x answers can cut the reply off with finish_reason: "length". MiniMax recommends 131,072 and allows 524,288.
• Timeouts. At high and above, a single call can take a minute. Client and proxy timeouts tuned for a fast model need to be raised to 120 seconds or more.
• Values that silently do nothing. Through AIHubMix, none, minimal, and an unknown value like auto were all accepted, and the model still thought. MiniMax's own endpoints reject unknown values, according to a gateway project's tests (sub2api issue #8025). Use one of the five documented values.
• Tools that don't expose the levels. OpenCode currently resolves no effort variants for this model, and some frameworks send "thinking disabled", which triggers the 400. Check what your tool actually sends.
• Mixed models in one pipeline. M3 and M2.x ignore the effort field. If you route between models, an effort level that saves money on Flash does nothing on the others.

Setting it on each protocol

All three through AIHubMix with one key. The quick start covers keys, and the unified reasoning parameters page covers how AIHubMix handles reasoning fields across vendors.

Chat Completions:

curl https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "minimax-m3.1-flash",
       "reasoning_effort": "low",
       "max_tokens": 32768,
       "messages": [{"role": "user", "content": "Write a function that merges overlapping date ranges."}]}'

Anthropic Messages (Python SDK; output_config goes in extra_body if your SDK version doesn't know the field):

import os
import anthropic

client = anthropic.Anthropic(base_url="https://aihubmix.com", api_key=os.environ["AIHUBMIX_API_KEY"])

msg = client.messages.create(
    model="minimax-m3.1-flash",
    max_tokens=32768,
    messages=[{"role": "user", "content": "Write a function that merges overlapping date ranges."}],
    extra_body={"output_config": {"effort": "medium"}},
)
print(msg.usage)

Responses:

import os
from openai import OpenAI

client = OpenAI(base_url="https://aihubmix.com/v1", api_key=os.environ["AIHUBMIX_API_KEY"])

resp = client.responses.create(
    model="minimax-m3.1-flash",
    reasoning={"effort": "low"},
    max_output_tokens=32768,
    input="Write a function that merges overlapping date ranges.",
)
print(resp.usage)

Check usage on the first few calls. Chat Completions reports thinking as completion_tokens_details.reasoning_tokens, Messages as output_tokens_details.thinking_tokens, and Responses as output_tokens_details.reasoning_tokens. If those numbers don't move when you change the level, the setting isn't reaching the model.

FAQ

What is the default effort for MiniMax M3.1 Flash?
Max. If the request has no effort field, the model thinks at the deepest level.

Can I turn thinking off completely?
No. Disabling thinking returns HTTP 400 on MiniMax's API. The lowest level is low, and on short prompts low often uses no thinking tokens at all.

Which effort level should I use for coding?
Start at low for single-function fixes and small reviews, medium for multi-file changes, and move up only when a task fails. In our test, low fixed a two-bug function correctly every time.

Is max effort more accurate?
Not on our test task: every level passed all 215 tests. Max used far more tokens and time. Higher levels may help on harder tasks, but nobody has published data showing where.

Why did the same request take 10 seconds once and 56 seconds the next time?
Thinking depth varies from run to run even at a fixed level. One low-effort run on the Messages endpoint used about ten times the thinking tokens of another.

Does reasoning_effort none work through AIHubMix?
It's accepted without an error, but the model still thinks. Use low instead.

How do I see how many thinking tokens a call used?
Look at the usage object: reasoning_tokens on Chat Completions and Responses, thinking_tokens on the Messages API.

Keep reading: the MiniMax M3.1 Flash series

• For the bigger picture behind this setting, 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
• Effort is one of several things that change when M2.5/M2.7 code moves over. This post covers the 400 errors and the rest: Moving Off MiniMax M2.5/M2.7 Before Nov 18: Fixing M3.1 Flash's "requires adaptive thinking" 400
• At low effort, Flash was the cheapest of three models on the same fix. Here is how its default compares with DeepSeek's and Haiku's: MiniMax M3.1 Flash vs DeepSeek V4.1 Flash vs Claude Haiku 5.5: One Bug Fix, Three Bills

Sources

• MiniMax: Model Invocation (text generation guide)
• MiniMax: Messages API reference
• AIHubMix: MiniMax M3.1 Flash
• AIHubMix: Unified Reasoning Parameters
• sub2api issue #8025: MiniMax M3 / M3.1 Flash effort support