跳到正文
DEV Community· Yong Yu·· 2026-10-20AI 評分66

MiniMax M3.1 Flash 預設推理力度為 max,文章分析 API 設定與 DeepSeek Flash 成本差異

MiniMax M3.1 Flash Thinks at Max by Default: First Call, Effort as the Price Knob, and Cache Math vs DeepSeek Flash

AI 導讀

MiniMax M3.1 Flash 未指定 reasoning_effort 時預設為 max,思考功能不能關閉;作者拆解相關 API 設定及成本影響。

正文

On October 19 MiniMax shipped M3.1 Flash and confirmed that "Space Bunny", the anonymous model some coding-tool users had been trying (MiniMax says it processed 200T+ tokens), was an early version of it. The headline: list price $0.15 / $0.60 per 1M tokens (input / output), $0.015 for cached input, a 1M context, text + image + video input, and MiniMax's claim of ~3× faster inference and 70% lower agentic-task cost than the previous generation.

MiniMax's own numbers include DeepSWE v1.1 73.7%, BankerToolBench 76.2, OSWorld V2 61.7, and CyberGym 82%. Artificial Analysis independently lists it at 43 on its Intelligence Index, $0.22 per index task, ~105 output tokens/s, and 180M output tokens to run the index (median for its class: 99M). VentureBeat, citing AA, also reports a 93% hallucination rate on AA-Omniscience. That doesn't mean 93% of answers are wrong. It means that when the model didn't know, it almost always guessed instead of saying so.

Reactions were split: HN commenters who had used Space Bunny called it "benchmaxed", and a V2EX user reported tasks burning 20M tokens where DeepSeek's Flash finished in 1M. This post skips that argument and covers the settings that decide what the model costs in your code.

1. First call: effort defaults to max, and thinking can't be turned off

OpenAI-compatible endpoint, with the one line I'd add on day one:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["MINIMAX_API_KEY"], base_url="https://api.minimax.io/v1")
r = client.chat.completions.create(
    model="MiniMax-M3.1-Flash",
    reasoning_effort="low",          # omit this and you get "max"
    max_completion_tokens=4096,      # thinking tokens count against this
    messages=[{"role": "user", "content": "Label this ticket: billing, bug, or other? 'I was charged twice.'"}],
)
print(getattr(r.choices[0].message, "reasoning_content", None))
print(r.choices[0].message.content)

(Not run; no key.) The docs list the rules:

  • reasoning_effort accepts low | medium | high | xhigh | max, and omitting it means max. On the Anthropic-compatible endpoint (which MiniMax recommends) the field is output_config.effort. On the Responses API it's reasoning.effort.
  • Thinking is always on. thinking: {"type": "disabled"} or reasoning_effort: "none" returns HTTP 400 ("requires adaptive thinking", code 2013). That's a change from MiniMax-M3, where disabled skipped thinking. If your M3 classifier disabled thinking, the same request now fails.
  • temperature and top_p do nothing (always 1 and 0.95), and neither do presence_penalty, frequency_penalty and logit_bias. Effort is the only control you have.
  • Thinking tokens count toward max_tokens / max_completion_tokens. Set it too low and you get finish_reason: "length" with an empty content.
  • n only supports 1, and service_tier (the 1.5× "priority" lane) isn't available for this model.

runs/22-minimax-m3-1-flash/lint_request.py turns those rules into an offline pre-flight check. Excerpt of the actual output:

[copied from a GPT/DeepSeek config]
  WARN reasoning_effort omitted -> defaults to 'max' (slowest, most output tokens). Set it explicitly.
  WARN temperature has no effect (temperature is always 1, top_p always 0.95).
  WARN top_p has no effect (always 0.95).
  WARN output budget 800 counts thinking tokens too; at effort max (default) you risk finish_reason='length' with empty content.
[cache-busting system prompt]
  WARN system prompt contains a timestamp/id-looking value; cache is prefix-matched (tools -> system -> messages), so everything after the tool list misses the cache on every call.
[explicit low-effort classifier]
  OK

The 2,048-token "too small" threshold is my own guess. MiniMax doesn't publish a number.

2. Why the default matters: one public data point

X user @bitsquin posted a small Python bug-fix test (215 hidden tests): M3.1 Flash at default settings took 56 s and $0.0045, and at low effort 9.5 s and $0.0006, and fixed the same two bugs. That's 5.9× the time and 7.5× the cost for the same result on that task. It's one person's test, and I didn't reproduce it. HN user chriddyp, posting Plotly's data-analytics benchmark, said it tied the top score (41/43) but was the slowest model they've tested, "because of the number of tokens it uses, not the inference speed." PingWest saw steady ~100 tokens/s in MiniMax Code on the Preview build, but the model kept re-checking finished work.

The problem isn't speed per token. It's how many tokens the default spends. My untested starting point: low for classification, extraction and routing, medium/high for normal coding-agent turns, and xhigh/max only where you've measured that the extra tokens pay off.

3. Cost math against DeepSeek Flash

cost_math.py uses the same example agent turn as my Muse Spark Open and DeepSeek posts (60K input with 50K from cache, 4K output including reasoning). Actual output:

model                         $/turn  $/1k turns
minimax-m3.1-flash           0.00465        4.65
deepseek-flash off-peak      0.00405        4.05
deepseek-flash peak          0.00810        8.10
minimax-m3.1-flash, zero cache hits: 0.01140/turn (11.40/1k)

The miss and output prices match DeepSeek's off-peak rates. The gap is the cache hit: $0.015 vs DeepSeek's $0.003 off-peak. Grow the cached prefix and it widens (excerpt):

cached prefix | minimax $/turn | ds off-peak | ds peak  (10K fresh in, 4K out)
            0 |        0.00390 |     0.00390 | 0.00780
      200,000 |        0.00690 |     0.00450 | 0.00900
      900,000 |        0.01740 |     0.00660 | 0.01320
MiniMax beats DeepSeek PEAK until the cached prefix passes ~433,333 tokens (10K fresh/4K out)

DeepSeek's peak windows land on Toronto evenings and early mornings, so for overnight batch jobs that run in those windows, M3.1 Flash is cheaper unless the cached prefix is huge. Long-context agents that re-send a big cached prefix are better off on DeepSeek. And once effort climbs, output dominates: at 16K output tokens per turn, 81% of the bill is output.

4. The usage-parsing trap

MiniMax returns cache usage in two shapes, and they mean different things:

  • OpenAI-compatible: prompt_tokens includes cached tokens (prompt_tokens_details.cached_tokens)
  • Anthropic-compatible: input_tokens excludes them (cache_read_input_tokens)

Applied to the literal sample responses in MiniMax's Tool Use guide:

OpenAI shape  correct  miss/hit/out=(2, 466, 37)  $29.49 per 1M such calls
OpenAI shape  no-cache miss/hit/out=(468, 0, 37)  $92.40  (3.13x)
OpenAI shape  double   miss/hit/out=(468, 466, 37)  $99.39  (3.37x)
Anthropic     correct  miss/hit/out=(280, 188, 37)  $67.02 per 1M such calls
Anthropic     subtract miss/hit/out=(92, 188, 37)  $38.82  (0.58x)

A dashboard shared by both SDK paths can be off by 3× one way or ~40% the other. Write one parser per protocol.

5. Agent loops: append the whole message

The Tool Use guide says to append the full assistant message, including reasoning_content and tool_calls (on the Anthropic path, the whole response.content list). Rebuilding history from content alone breaks interleaved thinking. Unlike DeepSeek, the docs describe no 400 for this, so the failure is quiet. The model also skips thinking on simple tool calls, so read reasoning_content with getattr(..., None). check_replay() in the lint script flags both cases.

Reality check (and what I skipped)

MiniMax's blog says weights will come "later". VentureBeat reports October 23, with no license announced, and Artificial Analysis still lists the model as proprietary. I did not call the API, measure token counts per effort level, reproduce any benchmark or the @bitsquin test, check hallucinations, or test video input. Given the AA finding, put retrieval or a verifier in front of anything factual it writes.

Why this matters

On cheap reasoning models, the price you pay per task depends on your effort setting more than on the per-token rate. Set effort explicitly, parse usage per protocol, and keep the cached prefix byte-stable. Then compare models on your own tasks.


YongBo Yu is an AI engineer in Toronto building LLM workflows and agent systems. More at yongbo-yu.vercel.app and GitHub.

來源:DEV Community · dev.to